path: root/plugins/org.eclipse.eef.ide.ui/src/org/eclipse/eef/ide/ui/api/widgets/EEFStyleHelper.java

/*******************************************************************************
 * Copyright (c) 2016 Obeo.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.eef.ide.ui.api.widgets;

import java.util.Iterator;
import java.util.List;

import org.eclipse.eef.EEFConditionalStyle;
import org.eclipse.eef.EEFWidgetDescription;
import org.eclipse.eef.EEFWidgetStyle;
import org.eclipse.eef.common.api.utils.Util;
import org.eclipse.eef.core.api.utils.EvalFactory;
import org.eclipse.eef.ide.ui.internal.widgets.styles.EEFColor;
import org.eclipse.eef.ide.ui.internal.widgets.styles.EEFFont;
import org.eclipse.eef.util.EEFConditionalStyleToWidgetStyleSwitch;
import org.eclipse.eef.util.EEFDescriptionToConditionalStylesSwitch;
import org.eclipse.eef.util.EEFDescriptionToWidgetStyleSwitch;
import org.eclipse.emf.ecore.util.Switch;
import org.eclipse.sirius.common.interpreter.api.IInterpreter;
import org.eclipse.sirius.common.interpreter.api.IVariableManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;

/**
 * This utility class contains various helper method to manipulate styles.
 *
 * @author sbegaudeau
 */
public class EEFStyleHelper {
	/**
	 * The interpreter.
	 */
	private IInterpreter interpreter;

	/**
	 * The variable manager.
	 */
	private IVariableManager variableManager;

	/**
	 * The constructor.
	 *
	 * @param interpreter
	 *            The interpreter
	 * @param variableManager
	 *            The variable manager
	 */
	public EEFStyleHelper(IInterpreter interpreter, IVariableManager variableManager) {
		this.interpreter = interpreter;
		this.variableManager = variableManager;
	}

	/**
	 * Returns the widget style to use from the given widget description.
	 *
	 * @param widgetDescription
	 *            The widget description
	 * @return The widget style to use
	 */
	public EEFWidgetStyle getWidgetStyle(EEFWidgetDescription widgetDescription) {
		EEFWidgetStyle widgetStyle = null;
		List<EEFConditionalStyle> conditionalStyles = this.getDescriptionToConditionalStylesSwitch().doSwitch(widgetDescription);
		Iterator<EEFConditionalStyle> iterator = conditionalStyles.iterator();
		while (widgetStyle == null && iterator.hasNext()) {
			EEFConditionalStyle conditionalStyle = iterator.next();
			String preconditionExpression = conditionalStyle.getPreconditionExpression();
			Boolean preconditionValid = EvalFactory.of(interpreter, variableManager).logIfInvalidType(Boolean.class).evaluate(preconditionExpression);
			if (preconditionValid != null && preconditionValid.booleanValue()) {
				widgetStyle = this.getConditionalStyleToWidgetStyleSwitch().doSwitch(conditionalStyle);
			}
		}

		if (widgetStyle == null) {
			widgetStyle = this.getDescriptionToWidgetStyleSwitch().doSwitch(widgetDescription);
		}

		return widgetStyle;
	}

	/**
	 * Returns the switch to use to find the conditional styles of a widget description. The switch returned should be
	 * able to handle the default use case, as a result it is highly recommended to return a composed switch with the
	 * default one and new switches. Example:<br>
	 * <code>
	 * return new ComposedSwitch<>(Arrays.asList(new EEFDescriptionToConditionalStylesSwitch(), new
	 * CustomDescriptionToConditionalStylesSwitch()));
	 * </code>
	 *
	 * @return The switch to use to find the conditional styles of a widget description
	 */
	protected Switch<List<EEFConditionalStyle>> getDescriptionToConditionalStylesSwitch() {
		return new EEFDescriptionToConditionalStylesSwitch();
	}

	/**
	 * Returns the switch to use to find the style of a conditional style. The switch returned should be able to handle
	 * the default use case, as a result it is highly recommended to return a composed switch with the default one and
	 * new switches. Example:<br>
	 * <code>
	 * return new ComposedSwitch<>(Arrays.asList(new EEFConditionalStyleToWidgetStyleSwitch(), new
	 * CustomConditionalStyleToWidgetStyleSwitch()));
	 * </code>
	 *
	 * @return The switch to use to find the style of a conditional style
	 */
	protected Switch<EEFWidgetStyle> getConditionalStyleToWidgetStyleSwitch() {
		return new EEFConditionalStyleToWidgetStyleSwitch();
	}

	/**
	 * Returns the switch to use to find the style of a description. The switch returned should be able to handle the
	 * default use case, as a result it is highly recommended to return a composed switch with the default one and new
	 * switches. Example:<br>
	 * <code>
	 * return new ComposedSwitch<>(Arrays.asList(new EEFDescriptionToWidgetStyleSwitch(), new
	 * EEFDescriptionToWidgetStyleSwitch()));
	 * </code>
	 *
	 * @return The switch to use to find the style of a description.
	 */
	protected Switch<EEFWidgetStyle> getDescriptionToWidgetStyleSwitch() {
		return new EEFDescriptionToWidgetStyleSwitch();
	}

	/**
	 * Uses the given expressions to update the style using the given callback.
	 *
	 * @param fontNameExpression
	 *            The expression used to compute the name of the font
	 * @param fontSizeExpression
	 *            The expression used to compute the size of the font
	 * @param fontStyleExpression
	 *            The expression used to compute the style of the font
	 * @param defaultFont
	 *            The default font
	 * @param backgroundColorExpression
	 *            The expression used to compute the background color of the font
	 * @param foregroundColorExpression
	 *            The expression used to compute the foreground color of the font
	 * @param callback
	 *            The callback which will be called when a property of the style has been computed
	 */
	public void applyTextStyle(String fontNameExpression, String fontSizeExpression, String fontStyleExpression, Font defaultFont,
			String backgroundColorExpression, String foregroundColorExpression, IEEFTextStyleCallback callback) {
		if (!Util.isBlank(foregroundColorExpression)) {
			this.applyForegroundColor(foregroundColorExpression, callback);
		} else {
			callback.applyForegroundColor(new EEFColor((Color) null));
		}
		if (!Util.isBlank(backgroundColorExpression)) {
			this.applyBackgroundColor(backgroundColorExpression, callback);
		} else {
			callback.applyBackgroundColor(new EEFColor((Color) null));
		}

		String fontStyleValue = EvalFactory.of(interpreter, variableManager).logIfInvalidType(String.class).evaluate(fontStyleExpression);
		this.applyFont(fontNameExpression, fontSizeExpression, defaultFont, callback, fontStyleValue);
		this.applyFontStyle(callback, fontStyleValue);
	}

	/**
	 * Applies the foreground color computed using the given foreground color expression.
	 *
	 * @param foregroundColorExpression
	 *            The expression
	 * @param callback
	 *            The callback
	 */
	private void applyForegroundColor(String foregroundColorExpression, IEEFTextStyleCallback callback) {
		String foregroundColorCode = EvalFactory.of(interpreter, variableManager).logIfInvalidType(String.class).evaluate(foregroundColorExpression);
		if (!Util.isBlank(foregroundColorCode)) {
			callback.applyForegroundColor(new EEFColor(foregroundColorCode));
		}
	}

	/**
	 * Applies the background color computed using the given background color expression.
	 *
	 * @param backgroundColorExpression
	 *            The expression
	 * @param callback
	 *            The callback
	 */
	private void applyBackgroundColor(String backgroundColorExpression, IEEFTextStyleCallback callback) {
		String backgroundColorCode = EvalFactory.of(interpreter, variableManager).logIfInvalidType(String.class).evaluate(backgroundColorExpression);
		if (!Util.isBlank(backgroundColorCode)) {
			callback.applyBackgroundColor(new EEFColor(backgroundColorCode));
		}
	}

	/**
	 * Applies the font computed using the given expressions.
	 *
	 * @param fontNameExpression
	 *            The expression used to compute the name of the font
	 * @param fontSizeExpression
	 *            The expression used to compute the size of the font
	 * @param defaultFont
	 *            The default font
	 * @param callback
	 *            The callback
	 * @param fontStyleValue
	 *            The value of the font style (strikeout and/or underline)
	 */
	private void applyFont(String fontNameExpression, String fontSizeExpression, Font defaultFont, IEEFTextStyleCallback callback,
			String fontStyleValue) {
		FontData defaultFontData = defaultFont.getFontData()[0];
		String fontName = EvalFactory.of(interpreter, variableManager).logIfInvalidType(String.class).defaultValue(defaultFontData.getName())
				.evaluate(fontNameExpression);
		int fontSize = EvalFactory.of(interpreter, variableManager).logIfInvalidType(Integer.class)
				.defaultValue(Integer.valueOf(defaultFontData.getHeight())).evaluate(fontSizeExpression).intValue();

		int fontStyle = defaultFontData.getStyle();
		if (fontStyleValue == null) {
			fontStyle = 0;
		} else if (fontStyleValue.contains("bold")) { //$NON-NLS-1$
			fontStyle = fontStyle | SWT.BOLD;
		} else if (fontStyleValue.contains("italic")) { //$NON-NLS-1$
			fontStyle = fontStyle | SWT.ITALIC;
		}
		EEFFont font = new EEFFont(fontName, fontSize, fontStyle);
		callback.applyFont(font);
	}

	/**
	 * Applies the font style (underline and/or strikeout).
	 *
	 * @param callback
	 *            The callback
	 * @param fontStyleValue
	 *            The font style value
	 */
	private void applyFontStyle(IEEFTextStyleCallback callback, String fontStyleValue) {
		boolean strikeout = false;
		boolean underline = false;
		if (fontStyleValue != null && fontStyleValue.contains("underline")) { //$NON-NLS-1$
			underline = true;
		}
		if (fontStyleValue != null && fontStyleValue.contains("strike_through")) { //$NON-NLS-1$
			strikeout = true;
		}
		callback.applyFontStyle(strikeout, underline);
	}

	/**
	 * This class will be called to update the style of the text.
	 *
	 * @author sbegaudeau
	 */
	public interface IEEFTextStyleCallback {
		/**
		 * Applies the given font to the widget.
		 *
		 * @param font
		 *            The font
		 */
		void applyFont(EEFFont font);

		/**
		 * Applies the strikeout and/or underline styles.
		 *
		 * @param strikeout
		 *            <code>true</code> if the widget should be striked out, <code>false</code> otherwise
		 * @param underline
		 *            <code>true</code> if the widget should be underlined, <code>false</code> otherwise
		 */
		void applyFontStyle(boolean strikeout, boolean underline);

		/**
		 * Applies the given foreground color to the widget.
		 *
		 * @param color
		 *            The foreground color
		 */
		void applyForegroundColor(EEFColor color);

		/**
		 * Applies the given background color to the widget.
		 *
		 * @param color
		 *            The background color
		 */
		void applyBackgroundColor(EEFColor color);
	}
}