public DependenciesConfigurable()

in flex/src/com/intellij/lang/javascript/flex/projectStructure/ui/DependenciesConfigurable.java [100:323]
191 lines of code
33 McCabe index (conditional complexity)

  public DependenciesConfigurable(final ModifiableFlexBuildConfiguration bc,
                                  Project project,
                                  @NotNull FlexProjectConfigurationEditor configEditor,
                                  final ProjectSdksModel sdksModel,
                                  @NotNull ProjectStructureConfigurable projectStructureConfigurable) {
    mySkdsModel = sdksModel;
    myConfigEditor = configEditor;
    myDependencies = bc.getDependencies();
    myProject = project;
    myNature = bc.getNature();
    myProjectStructureConfigurable = projectStructureConfigurable;

    mySdkChangeDispatcher = EventDispatcher.create(ChangeListener.class);
    myDisposable = Disposer.newDisposable();

    final SdkModel.Listener listener = new SdkModel.Listener() {
      @Override
      public void sdkAdded(final @NotNull Sdk sdk) {
        rebuildSdksModel();
      }

      @Override
      public void beforeSdkRemove(final @NotNull Sdk sdk) {
        rebuildSdksModel();
      }

      @Override
      public void sdkChanged(final @NotNull Sdk sdk, final String previousName) {
        rebuildSdksModel();
      }

      @Override
      public void sdkHomeSelected(final @NotNull Sdk sdk, final @NotNull String newSdkHome) {
        rebuildSdksModel();
      }
    };
    sdksModel.addListener(listener);
    Disposer.register(myDisposable, () -> sdksModel.removeListener(listener));

    mySdkCombo.showNoneSdkItem();
    mySdkCombo.setEditButton(myEditButton, myProject, () -> mySdkCombo.getSelectedJdk());

    mySdkLabel.setLabelFor(mySdkCombo);

    mySdkCombo.addActionListener(e -> {
      if (myFreeze) {
        return;
      }
      updateOnSelectedSdkChange();
    });

    myComponentSetCombo.setModel(new DefaultComboBoxModel<>(ComponentSet.values()));
    myComponentSetCombo.setRenderer(SimpleListCellRenderer.create("", ComponentSet::getPresentableText));

    myFrameworkLinkageCombo.setRenderer(SimpleListCellRenderer.create("", value -> {
      if (value == LinkageType.Default) {
        Sdk sdk = mySdkCombo.getSelectedJdk();
        String sdkVersion = sdk != null ? sdk.getVersionString() : null;
        return sdkVersion == null ? "Default" : MessageFormat.format(
          "Default ({0})", FlexCommonUtils.getDefaultFrameworkLinkage(sdkVersion, myNature).getLongText());
      }
      else {
        return value.getLongText();
      }
    }));

    myFrameworkLinkageCombo.setModel(new DefaultComboBoxModel<>(BCUtils.getSuitableFrameworkLinkages(myNature)));

    ItemListener updateSdkItemsListener = new ItemListener() {
      @Override
      public void itemStateChanged(ItemEvent e) {
        if (myFreeze) {
          return;
        }
        DefaultMutableTreeNode sdkNode = findSdkNode();
        Sdk currentSdk = mySdkCombo.getSelectedJdk();
        if (sdkNode != null && currentSdk != null) {
          updateSdkEntries(sdkNode, currentSdk);
          myTable.refresh();
        }
      }
    };

    myTargetPlayerCombo.addItemListener(updateSdkItemsListener);
    myComponentSetCombo.addItemListener(updateSdkItemsListener);
    myFrameworkLinkageCombo.addItemListener(updateSdkItemsListener);

    myTargetPlayerWarning.setIcon(AllIcons.General.BalloonWarning12);
    myWarning.setIcon(UIUtil.getBalloonWarningIcon());

    myTable = new EditableTreeTable<>("", DEPENDENCY_TYPE_COLUMN) {
      @Override
      protected void render(SimpleColoredComponent c, MyTableItem item) {
        if (item != null) {
          item.getPresentableText().appendToComponent(c);
          c.setIcon(item.getIcon());
        }
      }
    };
    myTable.setRootVisible(false);
    myTable.getTree().setShowsRootHandles(true);

    myTablePanel.add(
      ToolbarDecorator.createDecorator(myTable)
        .setAddAction(this::addItem).setAddActionName(FlexBundle.message("add.dependency.action.name"))
        .setRemoveAction(anActionButton -> removeSelection()).setEditAction(button -> {
          MyTableItem item = myTable.getItemAt(myTable.getSelectedRow());
          if (item instanceof SharedLibraryItem) {
            editLibrary((SharedLibraryItem)item);
          }
          if (item instanceof ModuleLibraryItem) {
            editLibrary(((ModuleLibraryItem)item));
          }
        }).setRemoveActionUpdater(e -> {
          if (myTable.getSelectedRowCount() == 0) return false;
          for (int row : myTable.getSelectedRows()) {
            MyTableItem item = myTable.getItemAt(row);
            if (item instanceof SdkItem || item instanceof SdkEntryItem) return false;
          }
          return true;
        }).setEditActionUpdater(e -> {
          MyTableItem item = myTable.getItemAt(myTable.getSelectedRow());
          return item != null && item.canEdit();
        }).disableUpDownActions().createPanel(), BorderLayout.CENTER);

    new DoubleClickListener() {
      @Override
      protected boolean onDoubleClick(@NotNull MouseEvent e) {
        if (myTable.getSelectedRowCount() == 1) {
          myTable.getItemAt(myTable.getSelectedRow()).onDoubleClick();
          return true;
        }
        return false;
      }
    }.installOn(myTable);

    FlexBuildConfigurationsExtension.getInstance().getConfigurator().addListener(new FlexBCConfigurator.Listener() {
      @Override
      public void moduleRemoved(Module module) {
        // TODO return if module == this module
        Set<MyTableItem> itemsToRemove = new HashSet<>();
        // 1st-level nodes are always visible
        // 2nd-level nodes cannot refer to BC
        for (int row = 0; row < myTable.getRowCount(); row++) {
          MyTableItem item = myTable.getItemAt(row);
          if (item instanceof BCItem) {
            FlexBCConfigurable configurable = ((BCItem)item).configurable;
            if (configurable != null && configurable.getModule() == module) {
              itemsToRemove.add(item);
            }
          }
        }

        removeItems(itemsToRemove, true);
      }

      @Override
      public void buildConfigurationRemoved(FlexBCConfigurable configurable) {
        Pair<BCItem, Integer> item = findDependencyItem(configurable);
        if (item != null) {
          removeItems(Collections.singleton(item.first), true);
        }
      }

      @Override
      public void buildConfigurationRenamed(final FlexBCConfigurable configurable) {
        Pair<BCItem, Integer> item = findDependencyItem(configurable);
        if (item != null) {
          myTable.refreshItemAt(item.second);
        }
      }

      @Override
      public void natureChanged(final FlexBCConfigurable configurable) {
        Pair<BCItem, Integer> item = findDependencyItem(configurable);
        if (item != null) {
          final BuildConfigurationNature dependencyNature = item.first.configurable.getEditableObject().getNature();
          if (!FlexCommonUtils.checkDependencyType(myNature.outputType, dependencyNature.outputType, item.first.getLinkageType())) {
            removeItems(Collections.singleton(item.first), true);
          }
        }
      }

      private @Nullable Pair<BCItem, Integer> findDependencyItem(FlexBCConfigurable configurable) {
        if (configurable.isParentFor(DependenciesConfigurable.this)) {
          return null;
        }

        // 1st-level nodes are always visible
        // 2nd-level nodes cannot refer to BC
        for (int row = 0; row < myTable.getRowCount(); row++) {
          final MyTableItem item = myTable.getItemAt(row);

          if (item instanceof BCItem && ((BCItem)item).configurable == configurable) {
            // there may be only one dependency on a BC
            return Pair.create((BCItem)item, row);
          }
        }
        return null;
      }
    }, myDisposable);

    myConfigEditor.addModulesModelChangeListener(modules -> {
      FlexBCConfigurator configurator = FlexBuildConfigurationsExtension.getInstance().getConfigurator();
      for (Module module : modules) {
        for (CompositeConfigurable configurable : configurator.getBCConfigurables(module)) {
          FlexBCConfigurable flexBCConfigurable = FlexBCConfigurable.unwrap(configurable);
          if (flexBCConfigurable.isParentFor(this)) {
            resetTable(myDependencies.getSdkEntry(), true);
          }
        }
      }
    }, myDisposable);

    UserActivityWatcher watcher = new UserActivityWatcher();
    watcher.register(myMainPanel);
    myUserActivityDispatcher = EventDispatcher.create(UserActivityListener.class);
    watcher.addUserActivityListener(() -> {
      if (myFreeze) {
        return;
      }
      myUserActivityDispatcher.getMulticaster().stateChanged();
    }, myDisposable);
  }