import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void addDropDownOption(TerminationConfigOption terminationConfigOption) {
    if (terminationConfigOption == TerminationConfigOption.NESTED) {
        return;
    }
    AnchorListItem li1 = new AnchorListItem(dropDownNameMap.get(terminationConfigOption));
    li1.addClickHandler(h -> {
        presenter.onTerminationTypeSelected(terminationConfigOption.name());
    });
    for (int i = 0; i < dropdownMenuList.getWidgetCount(); i++) {
        AnchorListItem item = (AnchorListItem) dropdownMenuList.getWidget(i);
        TerminationConfigOption dropDownTerminationConfigOption = getDropDownOption(item.getText());
        if (dropDownTerminationConfigOption == null || terminationConfigOption.ordinal() < dropDownTerminationConfigOption.ordinal()) {
            dropdownMenuList.insert(li1,
                                    i);
            break;
        }
        if (i == dropdownMenuList.getWidgetCount() - 1) {
            dropdownMenuList.add(li1);
        }
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
protected AnchorListItem createTimeSelector(int time,
                                            String name,
                                            int configuredSeconds,
                                            final AnchorListItem refreshDisableButton) {
    final AnchorListItem oneMinuteRadioButton = GWT.create(AnchorListItem.class);
    oneMinuteRadioButton.setText(name);
    oneMinuteRadioButton.setIconFixedWidth(true);
    final int selectedRefreshTime = time;
    if (configuredSeconds == selectedRefreshTime) {
        oneMinuteRadioButton.setIcon(IconType.CHECK);
    }

    oneMinuteRadioButton.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            oneMinuteRadioButton.setIcon(IconType.CHECK);
            supportsRefreshInterval.onUpdateRefreshInterval(true,
                                                            selectedRefreshTime);
            refreshDisableButton.setActive(false);
            refreshDisableButton.setEnabled(true);
            refreshDisableButton.setText(constants.Disable_autorefresh());
        }
    });

    return oneMinuteRadioButton;
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
/**
 * Adds a new tab to this panel that doesn't have any contents itself, but can contain multiple items that appear in
 * a dropdown menu when the tab is clicked. This dropdown menu is initially empty. Items can be added and removed
 * using the {@link DropDownTab#addItem(String, Widget)} and
 * {@link DropDownTab#removeItem(String, Widget)} methods.
 * @param label The text that should appear on the dropdown tab.
 * @return the container for the items that appear when the tab is clicked.
 */
public DropDownTab addDropdownTab(String label) {

    AnchorListItem tab = new AnchorListItem(label);

    // FIXME should actually subclass AnchorListItem and add a <b class=caret/> to the anchor elem
    tab.setIcon(IconType.ANGLE_DOWN);
    tab.setIconPosition(IconPosition.RIGHT);

    tab.addStyleName(Styles.DROPDOWN_TOGGLE);
    tab.setDataToggle(Toggle.DROPDOWN);

    DropDownTab dropDownTab = new DropDownTab(tab);
    tab.add(dropDownTab);
    addDropdownTab(dropDownTab);

    return dropDownTab;
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void setSplashScreenList(final List<SplashScreenListEntry> splashScreens) {
    dropdown.clear();
    for (final SplashScreenListEntry entry : splashScreens) {
        final AnchorListItem item = new AnchorListItem(entry.getScreenName());
        item.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                entry.getShowCommand().execute();
            }
        });
        dropdown.add(item);
    }
    if (dropdown.getWidgetCount() == 0) {
        dropdown.add(new DropDownHeader(WorkbenchConstants.INSTANCE.splashScreenNoneAvailable()));
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void addMenuItem(final String id,
                        final String label,
                        final String parentId,
                        final Command command,
                        final MenuPosition position) {
    final AnchorListItem menuItem = GWT.create(AnchorListItem.class);
    menuItem.setText(label);
    if (command != null) {
        menuItem.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                command.execute();
            }
        });
    }
    getMenuItemWidgetMap().put(id,
                               menuItem);
    menuLabelMap.put(id,
                     label);
    dropDownMenu.add(menuItem);
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
protected ButtonGroup getMenuActionsButton() {
    return new ButtonGroup() {{
        add(new Button( Constants.INSTANCE.menu_button_actions()) {{
            setSize(ButtonSize.EXTRA_SMALL);
            addStyleName(Pull.RIGHT.getCssName());
            setDataToggle(Toggle.DROPDOWN);
        }} );
        add(new DropDownMenu() {{
            add(new AnchorListItem(Constants.INSTANCE.menu_edit()) {{
                addClickHandler(event -> getEditCommand().execute());
            }} );
            add(new AnchorListItem(Constants.INSTANCE.menu_clone() ) {{
                addClickHandler(event -> getCloneCommand().execute());
            }} );
            add(new AnchorListItem(Constants.INSTANCE.menu_export_csv() ) {{
                addClickHandler(event -> getExportCsvCommand().execute());
            }} );
            add(new AnchorListItem(Constants.INSTANCE.menu_export_excel()) {{
                addClickHandler(event -> getExportExcelCommand().execute());
            }} );
        }} );
    }};
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
private MenuItem buildDevMenuItem() {
    final DropDownMenu menu = new DropDownMenu() {{
        addStyleName("pull-right");
    }};
    for (final MenuDevCommand command : devCommands) {
        menu.add(new AnchorListItem(command.getText()) {{
            setIcon(command.getIcon());
            addClickHandler(event -> command.execute());
        }});
    }
    final IsWidget group = new ButtonGroup() {{
        add(new Button() {{
            setToggleCaret(false);
            setDataToggle(Toggle.DROPDOWN);
            setIcon(IconType.COG);
            setSize(ButtonSize.SMALL);
            setTitle("Development");
        }});
        add(menu);
    }};
    return MenuUtils.buildItem(group);
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Inject
public PhaseConfigFormViewImpl(final DropDownMenu dropdownMenuList,
                               final TranslationService translationService) {
    this.dropdownMenuList = dropdownMenuList;
    AnchorListItem constructionHeuristicListItem = new AnchorListItem(translationService.getTranslation(SolverEditorConstants.PhaseConfigFormViewImplConstructionHeuristic));
    constructionHeuristicListItem.addClickHandler(h -> presenter.addConstructionHeuristic());
    this.dropdownMenuList.add(constructionHeuristicListItem);

    AnchorListItem localSearchListItem = new AnchorListItem(translationService.getTranslation(SolverEditorConstants.PhaseConfigFormViewImplLocalSearch));
    localSearchListItem.addClickHandler(h -> presenter.addLocalSearch());
    this.dropdownMenuList.add(localSearchListItem);

    // TODO add Exhaustive search, ...
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void removeDropDownOption(TerminationConfigOption option) {
    for (int i = 0; i < dropdownMenuList.getWidgetCount(); i++) {
        AnchorListItem item = (AnchorListItem) dropdownMenuList.getWidget(i);
        if (dropDownNameMap.get(option).equals(item.getText())) {
            dropdownMenuList.remove(item);
            break;
        }
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void initSelectFieldDropdownOptions(List<ObjectProperty> options) {
    selectFieldDropdown.clear();
    for (ObjectProperty option : options) {
        AnchorListItem listItem = new AnchorListItem(option.getName());
        listItem.addClickHandler(c -> presenter.onFieldAdded(option,
                                                             true));
        selectFieldDropdown.add(listItem);
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Test
public void testUpdateRefreshInterval() {
    int time = 1;
    refreshSelectorMenuBuilder.createTimeSelector(time,
                                                  "",
                                                  time,
                                                  mock(AnchorListItem.class));
    clickHandler.onClick(new ClickEvent() {
    });

    verify(supportsRefreshInterval).onUpdateRefreshInterval(true,
                                                            time);
    verify(oneMinuteRadioButton,
           times(2)).setIcon(IconType.CHECK);
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Test
public void testSelectedRefreshInterval() {
    int time = 1;
    int selectedTime = 2;
    refreshSelectorMenuBuilder.createTimeSelector(time,
                                                  "",
                                                  selectedTime,
                                                  mock(AnchorListItem.class));

    verify(oneMinuteRadioButton,
           never()).setIcon(any(IconType.class));
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
private void addNewAnchorLink(DropDownMenu dropDownMenu,
                              String text,
                              PluginType pluginType,
                              boolean available) {
    if (available) {
        AnchorListItem anchor = new AnchorListItem(text);
        anchor.addClickHandler(event -> newPluginPopUp.show(pluginType));
        dropDownMenu.add(anchor);
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void setupBreadcrumbs(List<DirectoryBreadcrumb> breadcrumbs,
                             final ParameterizedCommand<String> breadcrumbAction) {
    dirs.clear();
    for (final DirectoryBreadcrumb breadCrumb : breadcrumbs) {
        final AnchorListItem bread = new AnchorListItem(breadCrumb.getName());
        bread.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                breadcrumbAction.execute(breadCrumb.getUri());
            }
        });
        dirs.add(bread);
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
private Widget makeMenuItemCommand(final MenuItemCommand cmdItem,
                                   final boolean isRoot) {
    if (isRoot) {
        final Button button = GWT.create(Button.class);
        button.setText(cmdItem.getCaption());
        button.setSize(ButtonSize.SMALL);
        button.setEnabled(cmdItem.isEnabled());
        button.addClickHandler(event -> cmdItem.getCommand().execute());
        cmdItem.addEnabledStateChangeListener(button::setEnabled);
        return button;
    } else {
        final AnchorListItem navbarLink = GWT.create(AnchorListItem.class);
        navbarLink.setText(cmdItem.getCaption());
        if (!cmdItem.isEnabled()) {
            navbarLink.addStyleName("disabled");
        }
        navbarLink.addClickHandler(event -> cmdItem.getCommand().execute());
        cmdItem.addEnabledStateChangeListener(enabled -> {
            if (enabled) {
                navbarLink.removeStyleName("disabled");
            } else {
                navbarLink.addStyleName("disabled");
            }
        });
        return navbarLink;
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void addMenuItem(final String id,
                        final String label,
                        final String parentId,
                        final Command command,
                        final MenuPosition position) {
    final AnchorListItem menuItem = GWT.create(AnchorListItem.class);
    menuItem.setText(label);
    if (command != null) {
        menuItem.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                command.execute();
            }
        });
    }
    getMenuItemWidgetMap().put(id,
                               menuItem);
    if (parentId == null) {
        positionMenuItem(menuItem,
                         position);
        navbarNav.add(menuItem);
    } else {
        final ComplexPanel parent = getMenuItemWidgetMap().get(parentId);
        if (parent != null) {
            parent.add(menuItem);
        }
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void addContextMenuItem(
        final String menuItemId,
        final String id,
        final String label,
        final String parentId,
        final Command command,
        final MenuPosition position) {

    final AnchorListItem menuItem = GWT.create(AnchorListItem.class);
    menuItem.setText(label);
    if (command != null) {
        menuItem.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                command.execute();
            }
        });
    }

    positionMenuItem(menuItem,
                     position);

    ComplexPanel contextContainer = getMenuItemContextWidgetMap().get(parentId);
    if (contextContainer == null) {
        contextContainer = getContextContainer(menuItemId);
    }
    contextContainer.add(menuItem);

    getMenuItemContextWidgetMap().put(id,
                                      menuItem);
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
@Override
public void visit(final MenuCustom<?> menuCustom) {
    final IsWidget customMenuItem = ((IsWidget) menuCustom.build()).asWidget();
    if (customMenuItem instanceof AnchorListItem) {
        final AnchorListItem view = (AnchorListItem) customMenuItem;
        setupEnableDisable(menuCustom,
                           view);
        this.hasMenuItems.addMenuItem(menuCustom.getPosition(),
                                      view);
    } else {
        buildMenuCustom(menuCustom,
                        this.hasMenuItems);
    }
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
protected Widget buildMenuCommand(final MenuItemCommand menuItemCommand,
                                  final HasMenuItems hasMenuItems) {
    final AnchorListItem item = createListItem(menuItemCommand,
                                               hasMenuItems);
    item.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            menuItemCommand.getCommand().execute();
        }
    });
    return item;
}
 

import org.gwtbootstrap3.client.ui.AnchorListItem; //导入依赖的package包/类
protected Widget buildMenuPerspective(final MenuItemPerspective menuItemPerspective,
                                      final HasMenuItems hasMenuItems) {
    final AnchorListItem item = createListItem(menuItemPerspective,
                                               hasMenuItems);
    item.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            IOC.getBeanManager().lookupBean(PlaceManager.class).getInstance().goTo(menuItemPerspective.getPlaceRequest());
        }
    });
    return item;
}