Editor Toolbar

Bedienelemente, wie Toolbarbuttons rufen z.B. EventHandler von Formularen auf. Je nach Formular müssen verschiedene EventHandler bedient werden. Statt nun immer wieder die onClick Handler an die Buttons zu heften, annotiere ich die EventHandler der GUI Klasse mit einer Button Konfiguration und lasse den EditorToolbar Konstruktor die Klasse untersuchen und die Konfiguration auslesen.

Ich habe ein Annotation Interface ToolbarbuttonConfig:

package net.empego.zk.annotation; import java.lang.annotation.Retention; import static java.lang.annotation.RetentionPolicy.*; @Retention(RUNTIME) public @interface ToolbarbuttonConfig { int ordernr(); String label(); String key() default ""; String tooltiptext(); String imageurl(); boolean visible(); }

das ich so einsetze:

/** * Delete Entity and close editors */ @ToolbarbuttonConfig(imageurl = "Delete.png", label = "Delete", ordernr = 7, tooltiptext = "Delete", visible = true) public void onDelete() { if(_entity.getId()!=0){ // reattach _entity to hibernate session Session hs = HibUtil.currentActiveSession(); hs.delete(_entity); } ((ApplicationContainerIF)this.getDesktop() .getAttribute("APPLICATION_CONTAINER")) .removeApplication(this); this.setParent(null); }

Diese Konfiguation legt z.B. fest welcher Toolbarbutton mit welchem Icon mit welcher Beschriftung an welcher Stelle in der zu generierenden Toolbar erscheinen soll und installiert auch den onClick EventHandler für den Button.

In der GUI Klasse braucht lediglich die Toolbar instanziert und als Bedienelement plaziert werden:

EditorToolbar toolbar = new EditorToolbar(this); toolbar.setId("ExplorerToolbar"); toolAndStatusBar.appendChild(toolbar);

EditorToolbar.java

package net.empego.zk.edit;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import net.empego.zk.annotation.ClipBoardButton;
import net.empego.zk.annotation.ToolbarbuttonConfig;
import net.empego.zk.annotation.XClipBoardButton;
import net.empego.zk.manager.ClipBoardManager;
import net.empego.zk.util.LabelFactory;
import net.empego.zk.util.StaticRessources;

import org.zkoss.zk.ui.Component;
import org.zkoss.zul.Button;
import org.zkoss.zul.Timer;
import org.zkoss.zul.Toolbar;
import org.zkoss.zul.Toolbarbutton;

/**
 * @author Thomas Mueller - empego.net The Editor Toolbar is a selfcreating
 *         toolbar which retrieves the toolbar configuration from the EditorIF
 *         instance set in the constructor. The configuration is derived with
 *         reflection and annotations. Each method in the EditorIF which starts
 *         with "on*" and has a ToolbarConfig annotation creates a Toolbarbutton
 *         in the Toolbar. The "on*" methods of the editor are the callback
 *         points for the onClick Event handler of the toolbarbuttons.
 */
public class EditorToolbar extends Toolbar {

	/**
	 * Stores the buttons under the "on*" eventhandler names of the editor. Used
	 * to modify buttons
	 */
	private Map<String, Toolbarbutton> buttons = new HashMap<String, Toolbarbutton>();

	private String buttonHeight = "50px";
	private String buttonWidth = "110px";
	private boolean imageToolbar = true;
	private boolean labelVisible = false;
	private String iconRepository = StaticRessources.getHOME() + "/icon/"; // "http://static.empego.net/icon/";
	private String iconSize = "16x16/";
	private String iconFolder = "actions/";
	private Timer timer;
	private Set<Toolbarbutton> clipboarButtons;
	boolean hasClipBoard = false;
	private Set<Toolbarbutton> xClipboarButtons;
	boolean hasXClipBoard = false;

	public EditorToolbar(Component toolbarOwner) {
		super();

		LabelFactory lf = new LabelFactory(toolbarOwner.getClass());

		// to keep the order of the buttons. (Care for the order number in the
		// ToolbarConfig)
		Map<Integer, Toolbarbutton> orderedButtons = new TreeMap<Integer, Toolbarbutton>();
		String keyPrefix = toolbarOwner.getClass().getSimpleName();

		for (Method method : toolbarOwner.getClass().getMethods()) {
			ToolbarbuttonConfig config = method
					.getAnnotation(ToolbarbuttonConfig.class);
			if (config != null && method.getName().startsWith("on")) {
				Toolbarbutton button = new Toolbarbutton();

				button.addForward("onClick", toolbarOwner, method.getName());
				if (imageToolbar) {
					button.setImage(iconRepository + iconSize + iconFolder
							+ config.imageurl());
				}

				if (labelVisible) {
					button.setLabel(lf.label(config.label()));
					button.setOrient("vertical");
					button.setHeight(buttonHeight);
					button.setWidth(buttonWidth);
				}

				button.setTooltiptext(lf.tooltiptext(config.label()));
				button.setVisible(config.visible());
				buttons.put(method.getName(), button);
				orderedButtons.put(config.ordernr(), button);

				if (method.isAnnotationPresent(ClipBoardButton.class)) {
					addClipboardButton(button);
					if (ClipBoardManager.hasClipboard()) {
						button.setVisible(true);
						hasClipBoard = ClipBoardManager.hasClipboard();
					}
				}
				if (method.isAnnotationPresent(XClipBoardButton.class)) {
					addXClipboardButton(button);
					if (ClipBoardManager.hasXClipboard()) {
						button.setVisible(true);
						hasXClipBoard = ClipBoardManager.hasXClipboard();
					}
				}

			}
		}

		for (Toolbarbutton button : orderedButtons.values()) {
			this.appendChild(button);
		}
	}

	public void onClipBoardTimer() {
		if (clipboarButtons != null) {
			if (!clipboarButtons.isEmpty()) {
				if (hasClipBoard != ClipBoardManager.hasClipboard()) {
					for (Toolbarbutton button : clipboarButtons) {
						button.setVisible(ClipBoardManager.hasClipboard());
					}
					hasClipBoard = ClipBoardManager.hasClipboard();
				}
			}
		}
		if (xClipboarButtons != null) {
			if (!xClipboarButtons.isEmpty()) {
				if (hasXClipBoard != ClipBoardManager.hasXClipboard()) {
					for (Toolbarbutton button : xClipboarButtons) {
						button.setVisible(ClipBoardManager.hasXClipboard());
					}
					hasXClipBoard = ClipBoardManager.hasXClipboard();
				}
			}
		}
	}

	private void installTimer() {
		timer = new Timer(ClipBoardManager.getClipboardPollDelayConfig());
		timer.setRepeats(true);
		timer.setRunning(true);
		timer.addForward("onTimer", this, "onClipBoardTimer");
		timer.start();
		this.appendChild(timer);
	}

	private void addClipboardButton(Toolbarbutton pasteButton) {
		if (timer == null) {
			installTimer();
		}
		if (clipboarButtons == null)
			clipboarButtons = new HashSet<Toolbarbutton>();
		clipboarButtons.add(pasteButton);

	}

	private void addXClipboardButton(Toolbarbutton xpasteButton) {
		if (timer == null) {
			installTimer();
		}

		if (xClipboarButtons == null)
			xClipboarButtons = new HashSet<Toolbarbutton>();
		xClipboarButtons.add(xpasteButton);
	}

	/**
	 * @return the buttonHeight
	 */
	public String getButtonHeight() {
		return buttonHeight;
	}

	/**
	 * @param buttonHeight
	 *            the buttonHeight to set
	 */
	public void setButtonHeight(String buttonHeight) {
		this.buttonHeight = buttonHeight;
	}

	/**
	 * @return the buttonWidth
	 */
	public String getButtonWidth() {
		return buttonWidth;
	}

	/**
	 * @param buttonWidth
	 *            the buttonWidth to set
	 */
	public void setButtonWidth(String buttonWidth) {
		this.buttonWidth = buttonWidth;
	}

	/**
	 * @return the imageToolbar
	 */
	public boolean isImageToolbar() {
		return imageToolbar;
	}

	/**
	 * @param imageToolbar
	 *            the imageToolbar to set
	 */
	public void setImageToolbar(boolean imageToolbar) {
		this.imageToolbar = imageToolbar;
	}

	/**
	 * @return the iconRepository
	 */
	public String getIconRepository() {
		return iconRepository;
	}

	/**
	 * @param iconRepository
	 *            the iconRepository to set
	 */
	public void setIconRepository(String iconRepository) {
		this.iconRepository = iconRepository;
	}

	/**
	 * @return the iconSize
	 */
	public String getIconSize() {
		return iconSize;
	}

	/**
	 * @param iconSize
	 *            the iconSize to set
	 */
	public void setIconSize(String iconSize) {
		this.iconSize = iconSize;
	}

	/**
	 * @return the iconFolder
	 */
	public String getIconFolder() {
		return iconFolder;
	}

	/**
	 * @param iconFolder
	 *            the iconFolder to set
	 */
	public void setIconFolder(String iconFolder) {
		this.iconFolder = iconFolder;
	}

	/**
	 * Constructor with EditorIF which uses this toolbaar
	 * 
	 * @param toolbarOwner
	 */

	/**
	 * @return the buttons
	 */
	public Map<String, Toolbarbutton> getButtons() {
		return buttons;
	}

	/**
	 * @param buttonName
	 * @return a specific Button
	 */
	public Toolbarbutton getButton(String buttonName) {
		return buttons.get(buttonName);
	}

	/**
	 * @return the labelVisible
	 */
	public boolean isLabelVisible() {
		return labelVisible;
	}

	/**
	 * @param labelVisible
	 *            the labelVisible to set
	 */
	public void setLabelVisible(boolean labelVisible) {
		this.labelVisible = labelVisible;
	}

}