import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
/**
 * Changes the foregroundIcon icon.
 *
 * Note: previous color setup and animations are reset as well.
 *
 * @param icon the icon which should be set as the new icon.
 * @param color the color of the new icon.
 */
public void setForegroundIcon(final GlyphIcons icon, final Color color) {
    // copy old images to replace later.
    final Text oldForegroundIcon = foregroundIcon;
    final Text oldForegroundFadeIcon = foregroundFadeIcon;

    // create new images.
    this.foregroundIcon = createIcon(icon, Layer.FOREGROUND);
    this.foregroundFadeIcon = createColorFadeIcon(icon, Layer.FOREGROUND);

    // setup icon color
    if (color != null) {
        setForegroundIconColor(color);
    }

    // replace old icons with new ones.
    getChildren().replaceAll((node) -> {
        if (node.equals(oldForegroundIcon)) {
            return foregroundIcon;
        } else if (node.equals(oldForegroundFadeIcon)) {
            return foregroundFadeIcon;
        } else {
            return node;
        }
    });
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
private void addChildren() {
    viewSwitcherPopUp.getChildren().clear();
    for (Map.Entry<GlyphIcons, EventHandler<ActionEvent>> glyphIconsEventHandlerEntry : eventHandler.entrySet()) {
        GlyphIcons icon = glyphIconsEventHandlerEntry.getKey();
        EventHandler<ActionEvent> handler = glyphIconsEventHandlerEntry.getValue();

        if (icon != parent) {
            FloatingButton element = new FloatingButton(new SVGIcon(icon, Constants.SMALL_ICON, true));
            viewSwitcherPopUp.getChildren().addAll(element);
            element.setOnAction(event -> {
                clickOnChild(icon);
                if (Objects.nonNull(handler)) {
                    handler.handle(event);
                }
            });
        }
    }
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
public static Label createIconLabel(GlyphIcons icon, String iconSize, String text, ContentDisplay contentDisplay, Paint colour, String style)
{
	Text iconLabel = GlyphsDude.createIcon(icon, iconSize);
	iconLabel.setFill(colour);
	Label label = new Label(text);
	label.setTextFill(colour);
	label.setStyle(style);
	label.setGraphic(iconLabel);
	label.setContentDisplay(contentDisplay);
	return label;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
/**
 * 
 * @param glyphsFactory
 * @param fontIcon
 * @return 
 */
public Node getIconAsNode(GlyphsFactory glyphsFactory, GlyphIcons fontIcon) {
    if (fontIcon == null) {
        throw new IllegalArgumentException("'fontIcon' can't be NULL."); // NOI18N
    }
    
    // TODO add more data (size, color...)
    final Node node = glyphsFactory.createIcon(fontIcon, "16px");// 1em
    
    return node;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
@Override
public GlyphIcons resolve(final String fontIconName) {
    final ObservableList<GlyphIcons> glyphIcons = FXCollections.observableArrayList();
    glyphIcons.addAll(MaterialDesignIcon.values());
    
    final Optional<GlyphIcons> oGlyphIcons = glyphIcons
            .stream()
            .filter((gi) ->  gi.name().equals(fontIconName) )
            .findFirst();
    if (oGlyphIcons.isPresent()) {
        return oGlyphIcons.get();
    }
    
    return null;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
@Test
public void testGlyphIconsIsFound() {
    final String fontIconName = "ACCOUNT_ALERT";
    final GlyphIcons actualGlyphIcons = handler.resolve(fontIconName);

    assertNotNull("actualGlyphIcons can't be NULL", actualGlyphIcons);

    final GlyphIcons expectedGlyphIcons = MaterialDesignIcon.ACCOUNT_ALERT;
    assertEquals("actualGlyphIcons.ACCOUNT_ALERT must be MaterialDesignIcon.ACCOUNT_ALERT", expectedGlyphIcons, actualGlyphIcons);
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
@Test
public void testGlyphIconsNOTFound() {
    final String fontIconName = "DONT_EXISTS";
    final GlyphIcons actualGlyphIcons = handler.resolve(fontIconName);

    assertNull("GlyphIcons.DONT_EXISTS can't exists", actualGlyphIcons);
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
public static GlyphIcons getIcon(Attribute attribute) {
    GlyphIcons iconName = attributeMap.get(attribute);
    if (iconName == null) {
        iconName = SQUARE_INC;
    }
    return iconName;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
public Action(String text, String accelerator, GlyphIcons icon,
	EventHandler<ActionEvent> action, ObservableBooleanValue disable,
	BooleanProperty selected)
{
	this.text = text;
	this.accelerator = (accelerator != null) ? KeyCombination.valueOf(accelerator) : null;
	this.icon = icon;
	this.action = action;
	this.disable = disable;
	this.selected = selected;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
/**
 * Constructor for a SVGIcon.
 *
 * @param icon the Icon to be set in the backgroundIcon
 * (can be chosen from one of the supported fonts from fontawesomefx)
 * @param size the size in px for the icon
 * @param styled true if color should be changed by theme, otherwise false
 */
public SVGIcon(final GlyphIcons icon, final double size, final boolean styled) {
    this(size, styled);
    this.foregroundIcon = createIcon(icon, Layer.FOREGROUND);
    this.foregroundFadeIcon = createColorFadeIcon(icon, Layer.FOREGROUND);
    this.backgroundIcon = null;
    this.backgroundFadeIcon = null;
    this.getChildren().addAll(foregroundIcon, foregroundFadeIcon);
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
private static Text createIcon(final GlyphIcons glyphIcon, final double size, final boolean styled) {
    final Text icon = GlyphsDude.createIcon(glyphIcon, String.valueOf(size));
    icon.setSmooth(true);
    if (styled) {
        icon.getStyleClass().clear();
        icon.getStyleClass().add(Constants.ICONS_CSS_STRING);
    }
    return icon;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
private static Text createColorFadeIcon(final GlyphIcons glyphIcon, final double size, final Layer layer) {
    final Text icon = createIcon(glyphIcon, size, layer == Layer.FOREGROUND);

    // should be only visible on fade.
    icon.setOpacity(Constants.FULLY_TRANSPARENT);
    return icon;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
/**
 * Changes the backgroundIcon icon.
 *
 * Note: previous color setup and animations are reset as well.
 *
 * @param icon the icon which should be set as the new icon.
 * @param color the color of the new icon.
 */
public void setBackgroundIcon(final GlyphIcons icon, final Color color) {
    // copy old images to replace later.
    final Text oldBackgroundIcon = backgroundIcon;
    final Text oldBackgroundFadeIcon = backgroundFadeIcon;

    // create new images.
    this.backgroundIcon = createIcon(icon, Layer.BACKGROUND);
    this.backgroundFadeIcon = createColorFadeIcon(icon, Layer.BACKGROUND);

    // setup icon color
    if (color != null) {
        setBackgroundIconColor(color);
    }

    // add background icon if not exists
    if (oldBackgroundIcon == null || oldBackgroundFadeIcon == null) {
        getChildren().clear();
        getChildren().addAll(this.backgroundIcon, this.backgroundFadeIcon, this.foregroundIcon, this.foregroundFadeIcon);
        return;
    }

    // replace old icons with new ones.
    getChildren().replaceAll((node) -> {
        if (node.equals(oldBackgroundIcon)) {
            return backgroundIcon;
        } else if (node.equals(oldBackgroundFadeIcon)) {
            return backgroundFadeIcon;
        } else {
            return node;
        }
    });
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
public final void addParentElement(final GlyphIcons icon, final EventHandler<ActionEvent> value) {
    parent = icon;
    eventHandler.put(icon, value);

    showParent();
    addChildren();

    setViewSwitchingButtonsVisible(visible);
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
public void clickOnChild(final GlyphIcons clicked) {
    parent = clicked;

    showParent();
    addChildren();
    switchingButtonsVisible();
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
/**
 * Creates a new Tab.
 *
 * @param pane the tab-content
 * @param icon the tab-icon
 * @return the new tab
 */
private Tab createTab(Pane pane, GlyphIcons icon) {
    Tab tab = new Tab();
    SVGIcon svgIcon = new SVGIcon(icon, Constants.EXTRA_SMALL_ICON, true);
    tab.setGraphic(svgIcon);
    tab.setContent(pane);
    pane.getStyleClass().add("tab-content-area");
    tab.getStyleClass().add("tab");
    return tab;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
public static void setButtonStackedIcons(Button button, GlyphIcons icon1, GlyphIcons icon2) {
	Region saveAsImg = GlyphsStack.create()
			.add(GlyphsBuilder.create(FontAwesomeIcon.class).glyph(icon1).size(iconSize(_buttonDefaultIconSize)).build())
			.add(GlyphsBuilder.create(FontAwesomeIcon.class).glyph(icon2).size(iconSize(_iconSmallSize)).build());
			
	button.setGraphic(saveAsImg);
	button.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
	
	fixButtonSize(button, _buttonDefaultIconSize);
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
public ViewModelListCellFactory<T> withIcon(Callback<T, GlyphIcons> toIcon, Callback<T, Paint> toColor) {
    this.toGraphic = viewModel -> {
        Text graphic = MaterialDesignIconFactory.get().createIcon(toIcon.call(viewModel));
        graphic.setFill(toColor.call(viewModel));
        return graphic;
    };
    return this;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
/**
 * Factory method to create an {@link UrlButton}
 * 
 * @param text
 *            optional button text
 * @param url
 * @param icon
 *            optional icon
 * @param style
 *            optional style classes
 * @return
 */
public static final UrlButton urlButton(String text, String url, GlyphIcons icon, String... style) {
    require(isNotBlank(url), "URL cannot be blank");
    UrlButton button = new UrlButton(text);
    button.setOnAction(e -> eventStudio().broadcast(new OpenUrlRequest(url)));
    if (nonNull(icon)) {
        GlyphsDude.setIcon(button, icon);
    }
    if (nonNull(style) && style.length > 0) {
        button.getStyleClass().addAll(style);
    }
    return button;
}
 

import de.jensd.fx.glyphs.GlyphIcons; //导入依赖的package包/类
@Override
public void accept(PdfDescriptorLoadingStatus t) {

    GlyphIcons icon = Optional.ofNullable(t).map(PdfDescriptorLoadingStatus::getIcon).orElse(null);
    if (nonNull(icon)) {
        GlyphsDude.setIcon(indicator, icon, ContentDisplay.CENTER);
    } else {
        indicator.setGraphic(null);
    }
    if (t != null && isNotBlank(t.getDescription())) {
        indicator.setTooltip(new Tooltip(t.getDescription()));
    } else {
        indicator.setTooltip(null);
    }
}