com.intellij.util.EventDispatcher Java Examples

public XBreakpointManagerImpl(final Project project, final XDebuggerManagerImpl debuggerManager, StartupManager startupManager) {
  myProject = project;
  myDebuggerManager = debuggerManager;
  myAllBreakpointsDispatcher = EventDispatcher.create(XBreakpointListener.class);
  myDependentBreakpointManager = new XDependentBreakpointManager(this);
  myLineBreakpointManager = new XLineBreakpointManager(project, myDependentBreakpointManager, startupManager);
  if (!project.isDefault()) {
    if (!ApplicationManager.getApplication().isUnitTestMode()) {
      HttpVirtualFileListener httpVirtualFileListener = this::updateBreakpointInFile;
      HttpFileSystem.getInstance().addFileListener(httpVirtualFileListener, project);
    }
    for (XBreakpointType<?, ?> type : XBreakpointUtil.getBreakpointTypes()) {
      addDefaultBreakpoint(type);
    }
  }
}
 

private <T extends XBreakpointProperties> void addBreakpoint(final XBreakpointBase<?, T, ?> breakpoint, final boolean defaultBreakpoint, boolean initUI) {
  XBreakpointType type = breakpoint.getType();
  if (defaultBreakpoint) {
    LOG.assertTrue(!myDefaultBreakpoints.containsKey(type), "Cannot have more than one default breakpoint (type " + type.getId() + ")");
    myDefaultBreakpoints.put(type, breakpoint);
  }
  else {
    myBreakpoints.put(type, breakpoint);
  }
  myAllBreakpoints.add(breakpoint);
  if (breakpoint instanceof XLineBreakpointImpl) {
    myLineBreakpointManager.registerBreakpoint((XLineBreakpointImpl)breakpoint, initUI);
  }
  EventDispatcher<XBreakpointListener> dispatcher = myDispatchers.get(type);
  if (dispatcher != null) {
    //noinspection unchecked
    dispatcher.getMulticaster().breakpointAdded(breakpoint);
  }
  getBreakpointDispatcherMulticaster().breakpointAdded(breakpoint);
}
 

public XDependentBreakpointManager(final XBreakpointManagerImpl breakpointManager) {
  myBreakpointManager = breakpointManager;
  myDispatcher = EventDispatcher.create(XDependentBreakpointListener.class);
  myBreakpointManager.addBreakpointListener(new XBreakpointAdapter<XBreakpoint<?>>() {
    public void breakpointRemoved(@Nonnull final XBreakpoint<?> breakpoint) {
      XDependentBreakpointInfo info = mySlave2Info.remove(breakpoint);
      if (info != null) {
        myMaster2Info.remove(info.myMasterBreakpoint, info);
      }

      Collection<XDependentBreakpointInfo> infos = myMaster2Info.removeAll((XBreakpointBase)breakpoint);
      if (infos != null) {
        for (XDependentBreakpointInfo breakpointInfo : infos) {
          XDependentBreakpointInfo removed = mySlave2Info.remove(breakpointInfo.mySlaveBreakpoint);
          if (removed != null) {
            myDispatcher.getMulticaster().dependencyCleared(breakpointInfo.mySlaveBreakpoint);
          }
        }
      }
    }
  });
}
 

private void doRemoveBreakpoint(XBreakpoint<?> breakpoint) {
  if (isDefaultBreakpoint(breakpoint)) {
    // removing default breakpoint should just disable it
    breakpoint.setEnabled(false);
  }
  else {
    XBreakpointType type = breakpoint.getType();
    XBreakpointBase<?, ?, ?> breakpointBase = (XBreakpointBase<?, ?, ?>)breakpoint;
    myBreakpoints.remove(type, breakpointBase);
    myAllBreakpoints.remove(breakpointBase);
    if (breakpointBase instanceof XLineBreakpointImpl) {
      myLineBreakpointManager.unregisterBreakpoint((XLineBreakpointImpl)breakpointBase);
    }
    breakpointBase.dispose();
    EventDispatcher<XBreakpointListener> dispatcher = myDispatchers.get(type);
    if (dispatcher != null) {
      //noinspection unchecked
      dispatcher.getMulticaster().breakpointRemoved(breakpoint);
    }
    getBreakpointDispatcherMulticaster().breakpointRemoved(breakpoint);
  }
}
 

public ArtifactImpl createCopy(EventDispatcher<ArtifactListener> dispatcher) {
  final ArtifactImpl artifact = new ArtifactImpl(myName, myArtifactType, myBuildOnMake, myRootElement, myOutputPath, dispatcher);
  for (Map.Entry<ArtifactPropertiesProvider, ArtifactProperties<?>> entry : myProperties.entrySet()) {
    final ArtifactProperties newProperties = artifact.myProperties.get(entry.getKey());
    //noinspection unchecked
    newProperties.loadState(entry.getValue().getState());
  }
  return artifact;
}
 

public void doNotify(final EventDispatcher<ChangeListListener> dispatcher) {
  if (myRemoved) {
    final ChangeListListener multicaster = dispatcher.getMulticaster();
    multicaster.changesMoved(myListCopy.getChanges(), myListCopy, myDefaultListCopy);
    multicaster.changeListRemoved(myListCopy);
  }
}
 

public void doNotify(final EventDispatcher<ChangeListListener> dispatcher) {
  if ((myMovedFrom != null) && (myListCopy != null)) {
    for(LocalChangeList fromList: myMovedFrom.keySet()) {
      final Collection<Change> changesInList = myMovedFrom.get(fromList);
      dispatcher.getMulticaster().changesMoved(changesInList, fromList, myListCopy);
    }
  }
}
 

private <T extends XBreakpointProperties> EventDispatcher<XBreakpointListener> getOrCreateDispatcher(final XBreakpointType<?, T> type) {
  EventDispatcher<XBreakpointListener> dispatcher = myDispatchers.get(type);
  if (dispatcher == null) {
    dispatcher = EventDispatcher.create(XBreakpointListener.class);
    myDispatchers.put(type, dispatcher);
  }
  return dispatcher;
}
 

public void fireBreakpointChanged(XBreakpointBase<?, ?, ?> breakpoint) {
  if (!myAllBreakpoints.contains(breakpoint)) {
    return;
  }

  if (breakpoint instanceof XLineBreakpointImpl) {
    myLineBreakpointManager.breakpointChanged((XLineBreakpointImpl)breakpoint);
  }
  EventDispatcher<XBreakpointListener> dispatcher = myDispatchers.get(breakpoint.getType());
  if (dispatcher != null) {
    //noinspection unchecked
    dispatcher.getMulticaster().breakpointChanged(breakpoint);
  }
  getBreakpointDispatcherMulticaster().breakpointChanged(breakpoint);
}
 

@Nonnull
private <L> InvocationHandler createTopicHandler(@Nonnull Topic<L> topic) {
  return (proxy, method, args) -> {
    if (method.getDeclaringClass().getName().equals("java.lang.Object")) {
      return EventDispatcher.handleObjectMethod(proxy, args, method.getName());
    }
    sendMessage(new Message(topic, method, args));
    return NA;
  };
}
 

public ArtifactImpl(@Nonnull String name, @Nonnull ArtifactType artifactType, boolean buildOnMake, @Nonnull CompositePackagingElement<?> rootElement,
                    String outputPath,
                    EventDispatcher<ArtifactListener> dispatcher) {
  myName = name;
  myArtifactType = artifactType;
  myBuildOnMake = buildOnMake;
  myRootElement = rootElement;
  myOutputPath = outputPath;
  myDispatcher = dispatcher;
  myProperties = new HashMap<ArtifactPropertiesProvider, ArtifactProperties<?>>();
  resetProperties();
}
 

public void doNotify(final EventDispatcher<ChangeListListener> dispatcher) {
  dispatcher.getMulticaster().changeListAdded(myNewListCopy);
}
 

public void doNotify(final EventDispatcher<ChangeListListener> dispatcher) {
  if (myListCopy != null && (! myListCopy.isReadOnly())) {
    dispatcher.getMulticaster().changeListRenamed(myListCopy, myFromName);
  }
}
 

public void doNotify(final EventDispatcher<ChangeListListener> dispatcher) {
  dispatcher.getMulticaster().defaultListChanged(myOldDefaultListCopy, myNewDefaultListCopy);
}
 

public void doNotify(final EventDispatcher<ChangeListListener> dispatcher) {
  // +-
  dispatcher.getMulticaster().changeListChanged(myListCopy);
}
 

public void doNotify(final EventDispatcher<ChangeListListener> dispatcher) {
  if (myListCopy != null) {
    dispatcher.getMulticaster().changeListCommentChanged(myListCopy, myOldComment);
  }
}
 

public DelayedNotificator(@Nonnull EventDispatcher<ChangeListListener> dispatcher,
                          @Nonnull ChangeListManagerImpl.Scheduler scheduler) {
  myDispatcher = dispatcher;
  myScheduler = scheduler;
}
 

@SuppressWarnings("unchecked")
public <T extends EventListener> Disposable addListener(Class<T> clazz, T value) {
  EventDispatcher<T> eventDispatcher = myListeners.computeIfAbsent(clazz, EventDispatcher::create);
  eventDispatcher.addListener(value);
  return () -> eventDispatcher.removeListener(value);
}
 

@SuppressWarnings("unchecked")
public <T extends EventListener> T getDispatcher(Class<T> clazz) {
  return (T)myListeners.computeIfAbsent(clazz, EventDispatcher::create).getMulticaster();
}
 

void doNotify(final EventDispatcher<ChangeListListener> dispatcher);