Java ActionCallback.REJECTED属性代码示例

@NotNull
public ActionCallback queueUpdateFrom(final Object element, final boolean forceResort, final boolean updateStructure) {
  if (getUi() == null) return ActionCallback.REJECTED;

  final ActionCallback result = new ActionCallback();

  getUi().invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeBuilder.queueUpdateFrom") {
    @Override
    public void perform() {
      if (updateStructure && forceResort) {
        getUi().incComparatorStamp();
      }
      getUi().queueUpdate(element, updateStructure).notify(result);
    }
  });


  return result;
}
 

@Override
protected ActionCallback _execute(PlaybackContext context) {
  final String[] keyValue = getText().substring(PREFIX.length()).trim().split("=");
  if (keyValue.length != 2) {
    context.error("Expected expresstion: " + PREFIX + " key=value", getLine());
    return ActionCallback.REJECTED;
  }

  final String key = keyValue[0];
  final String value = keyValue[1];

  context.storeRegistryValue(key);

  Registry.get(key).setValue(value);

  return ActionCallback.DONE;
}
 

private ActionCallback tryToInitSessionFromFocus(@Nullable SwitchTarget preselected, boolean showSpots) {
  if (isSessionActive()) {
    return ActionCallback.REJECTED;
  }

  Component owner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
  SwitchProvider provider = SwitchProvider.KEY.getData(DataManager.getInstance().getDataContext(owner));
  if (provider != null) {
    return initSession(new SwitchingSession(this, provider, myAutoInitSessionEvent, preselected, showSpots));
  }

  return ActionCallback.REJECTED;
}
 

public ActionCallback _execute(PlaybackContext context) {
  final String s = getText().substring(PREFIX.length()).trim();

  try {
    final Integer delay = Integer.valueOf(s);
    context.getRobot().delay(delay.intValue());
  }
  catch (NumberFormatException e) {
    dumpError(context, "Invalid delay value: " + s);
    return ActionCallback.REJECTED;
  }

  return ActionCallback.DONE;
}
 

public ActionCallback goRight() {
  if (mySelectedIndex == mySlides.size() - 1) {
    return ActionCallback.REJECTED;
  }
  mySelectedIndex++;
  return applySlide(JBCardLayout.SwipeDirection.FORWARD);
}
 

public ActionCallback _execute(PlaybackContext context) {
  final String one = getText().substring(PREFIX.length());
  if (!one.endsWith(POSTFIX)) {
    dumpError(context, "Expected " + "]");
    return ActionCallback.REJECTED;
  }

  type(context.getRobot(), getFromShortcut(one.substring(0, one.length() - 1).trim()));

  return ActionCallback.DONE;
}
 

ActionCallback fireModifiedAdded(@NotNull final Configurable configurable, @Nullable OptionsEditorColleague requestor) {
  if (myModified.contains(configurable)) return ActionCallback.REJECTED;

  myModified.add(configurable);

  return notify(new ColleagueAction() {
    public ActionCallback process(final OptionsEditorColleague colleague) {
      return colleague.onModifiedAdded(configurable);
    }
  }, requestor);

}
 

ActionCallback fireModifiedRemoved(@NotNull final Configurable configurable, @Nullable OptionsEditorColleague requestor) {
  if (!myModified.contains(configurable)) return ActionCallback.REJECTED;

  myModified.remove(configurable);

  return notify(new ColleagueAction() {
    public ActionCallback process(final OptionsEditorColleague colleague) {
      return colleague.onModifiedRemoved(configurable);
    }
  }, requestor);
}
 

ActionCallback fireErrorsChanged(final Map<Configurable, ConfigurationException> errors, OptionsEditorColleague requestor) {
  if (myErrors.equals(errors)) return ActionCallback.REJECTED;

  myErrors = errors != null ? errors : new HashMap<Configurable, ConfigurationException>();

  return notify(new ColleagueAction() {
    public ActionCallback process(final OptionsEditorColleague colleague) {
      return colleague.onErrorsChanged();
    }
  }, requestor);
}
 

/** @see #select(Configurable) */
@Deprecated
public ActionCallback select(Class<? extends Configurable> configurableClass) {
  final Configurable configurable = findConfigurable(configurableClass);
  if (configurable == null) {
    return ActionCallback.REJECTED;
  }
  return select(configurable);
}
 

private ActionCallback updateIfCurrent(final Configurable configurable) {
  if (getContext().getCurrentConfigurable() == configurable && configurable != null) {
    updateDetails();
    final ConfigurableContent content = myConfigurable2Content.get(configurable);
    content.updateBannerActions();
    return ActionCallback.DONE;
  } else {
    return ActionCallback.REJECTED;
  }
}
 

@Override
public ActionCallback navigateTo(@Nullable final Place place, final boolean requestFocus) {
  ModuleEditor editor = getModuleEditor();
  return editor == null ? ActionCallback.REJECTED : editor.navigateTo(place, requestFocus);
}
 

@Override
protected ActionCallback _execute(PlaybackContext context) {
  String[] args = getText().substring(PREFIX.length()).trim().split(" ");
  String syntaxText = "Syntax error, expected: " + PREFIX + " " + ON + "|" + OFF + " actionName";
  if (args.length != 2) {
    context.error(syntaxText, getLine());
    return ActionCallback.REJECTED;
  }
  
  final boolean on;
  if (ON.equalsIgnoreCase(args[0])) {
    on = true;
  } else if (OFF.equalsIgnoreCase(args[0])) {
    on = false;
  } else {
    context.error(syntaxText, getLine());
    return ActionCallback.REJECTED;
  }
  
  String actionId = args[1];
  final AnAction action = ActionManager.getInstance().getAction(actionId);
  if (action == null) {
    context.error("Unknown action id=" + actionId, getLine());
    return ActionCallback.REJECTED;
  }

  if (!(action instanceof ToggleAction)) {
    context.error("Action is not a toggle action id=" + actionId, getLine());
    return ActionCallback.REJECTED;
  }

  final InputEvent inputEvent = ActionCommand.getInputEvent(actionId);
  final ActionCallback result = new ActionCallback();

  context.getRobot().delay(Registry.intValue("actionSystem.playback.delay"));

  IdeFocusManager fm = IdeFocusManager.getGlobalInstance();
  fm.doWhenFocusSettlesDown(new Runnable() {
    @Override
    public void run() {
      final Presentation presentation = (Presentation)action.getTemplatePresentation().clone();
      AnActionEvent event =
          new AnActionEvent(inputEvent, DataManager.getInstance()
              .getDataContext(KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner()), ActionPlaces.UNKNOWN,
                            presentation, ActionManager.getInstance(), 0);

      ActionUtil.performDumbAwareUpdate(action, event, false);

      Boolean state = (Boolean)event.getPresentation().getClientProperty(ToggleAction.SELECTED_PROPERTY);
      if (state.booleanValue() != on) {
        ActionManager.getInstance().tryToExecute(action, inputEvent, null, ActionPlaces.UNKNOWN, true).doWhenProcessed(result.createSetDoneRunnable());
      }
      else {
        result.setDone();
      }
    }
  });


  return result;
}
 

@NotNull
@Override
public ActionCallback selectAndFocus(@Nullable final Content content, boolean requestFocus, final boolean forced, boolean implicit) {
  if (content == null) return ActionCallback.REJECTED;
  return getContentManager(content).setSelectedContent(content, requestFocus || shouldRequestFocus(), forced, implicit);
}
 

@NotNull
public ActionCallback cancelUpdate() {
  if (isDisposed()) return ActionCallback.REJECTED;

  return getUi().cancelUpdate();
}