ContextMenuConnector

package com.vaadin.contextmenu.client;

import info.magnolia.vaadin.addons.contextmenu.shared.MgnlContextMenuClientRpc;
import info.magnolia.vaadin.addons.contextmenu.shared.MgnlContextMenuServerRpc;

import java.util.List;
import java.util.logging.Logger;

import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Document;
import com.google.gwt.dom.client.SpanElement;
import com.google.gwt.event.logical.shared.CloseEvent;
import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Event.NativePreviewEvent;
import com.google.gwt.user.client.Event.NativePreviewHandler;
import com.google.gwt.user.client.ui.PopupPanel;
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.client.ApplicationConnection;
import com.vaadin.client.ComponentConnector;
import com.vaadin.client.ServerConnector;
import com.vaadin.client.UIDL;
import com.vaadin.client.WidgetUtil;
import com.vaadin.client.communication.StateChangeEvent;
import com.vaadin.client.extensions.AbstractExtensionConnector;
import com.vaadin.client.ui.Icon;
import com.vaadin.client.ui.VMenuBar;
import com.vaadin.client.ui.VMenuBar.CustomMenuItem;
import com.vaadin.contextmenu.ContextMenu;
import com.vaadin.contextmenu.client.MenuSharedState.MenuItemState;
import com.vaadin.shared.ui.Connect;

@SuppressWarnings("serial")
@Connect(ContextMenu.class)
public class ContextMenuConnector extends AbstractExtensionConnector {


    private class VMgnlMenuBar extends MyVMenuBar {

        VMgnlMenuBar(boolean subMenu, VMenuBar parentMenu) {
            super(subMenu, parentMenu);
        }

        VMgnlMenuBar() {}

        @Override
        public void showChildMenuAt(CustomMenuItem item, int top, int left) {
            super.showChildMenuAt(item, top, left);
        }

        @Override
        public void onClose(CloseEvent<PopupPanel> event) {
            super.onClose(event);
            getRpcProxy(MgnlContextMenuServerRpc.class).contextMenuClosed();
        }

        /**
         * Build the HTML content for a menu item.
         * <p>
         * For internal use only. May be removed or replaced in the future.
         */
        public String buildItemHTML(UIDL item) {
            // Construct html from the text and the optional icon
            StringBuffer itemHTML = new StringBuffer();
            if (item.hasAttribute("separator")) {
                itemHTML.append("<span>---</span>");
            } else {
                // Add submenu indicator
                if (item.getChildCount() > 0) {
                    String bgStyle = "";
                    itemHTML.append("<span class=\"" + getStylePrimaryName()
                            + "-submenu-indicator\"" + bgStyle
                            + ">&#x25BA;</span>");
                }

                itemHTML.append("<span class=\"" + getStylePrimaryName() + "-menuitem-caption\">");


                String itemText = item.getStringAttribute("text");
                if (!htmlContentAllowed) {
                    itemText = WidgetUtil.escapeHTML(itemText);
                }
                itemHTML.append(itemText);
                itemHTML.append("</span>");
            }
            return itemHTML.toString();
        }
    }

    protected MgnlContextMenuClientRpc serverToClientRPC = (MgnlContextMenuClientRpc) () -> {
        Widget clickTargetWidget = ((ComponentConnector) getParent()).getWidget();

        int targetW = clickTargetWidget.getOffsetWidth();
        int x = clickTargetWidget.getAbsoluteLeft() + targetW;
        int y = clickTargetWidget.getAbsoluteTop() + clickTargetWidget.getOffsetHeight();

        showMenu(x, y);
    };

    @SuppressWarnings("unused")
    private static Logger logger = Logger.getLogger("ContextMenuConnector");

    // TODO: make it so that we don't need this dummy root menu bar.
    private VMgnlMenuBar dummyRootMenuBar;
    private VMgnlMenuBar contextMenuWidget;

    @Override
    public MenuSharedState getState() {
        return (MenuSharedState) super.getState();
    }

    @Override
    public void onStateChanged(StateChangeEvent stateChangeEvent) {
        super.onStateChanged(stateChangeEvent);

        contextMenuWidget.clearItems();
        addMenuItemsFromState(contextMenuWidget, getState().menuItems);
    }

    @Override
    protected void init() {
        super.init();

        dummyRootMenuBar = new VMgnlMenuBar();

        VMenuBar.CustomMenuItem item = GWT.create(VMgnlMenuBar.CustomMenuItem.class);
        dummyRootMenuBar.getItems().add(item);

        contextMenuWidget = new VMgnlMenuBar(true, dummyRootMenuBar);
        item.setSubMenu(contextMenuWidget);

        // application connection that is used for all our overlays
        MyVOverlay.setApplicationConnection(this.getConnection());

        registerRpc(MgnlContextMenuClientRpc.class, serverToClientRPC);
        registerRpc(ContextMenuClientRpc.class, new ContextMenuClientRpc() {
            @Override
            public void showContextMenu(int x, int y) {
                showMenu(x, y);
            }
        });

        Event.addNativePreviewHandler(new NativePreviewHandler() {
            @Override
            public void onPreviewNativeEvent(NativePreviewEvent event) {
                if (event.getTypeInt() == Event.ONKEYDOWN
                        && contextMenuWidget.isPopupShowing()) {
                    boolean handled = contextMenuWidget.handleNavigation(
                            event.getNativeEvent().getKeyCode(),
                            event.getNativeEvent().getCtrlKey(),
                            event.getNativeEvent().getShiftKey());

                    if (handled) {
                        event.cancel();
                    }
                }
            }
        });
    }

    private void addMenuItemsFromState(VMenuBar menuToAddTo,
            List<MenuItemState> menuItems) {
        if (menuItems == null)
            return;

        for (MenuItemState menuItemState : menuItems) {
            CustomMenuItem newItem = addMenuItemToMenu(menuToAddTo,
                    menuItemState);

            if (menuItemState.childItems != null
                    && menuItemState.childItems.size() > 0) {
                VMenuBar subMenu = new MyVMenuBar(true, menuToAddTo);
                addMenuItemsFromState(subMenu, menuItemState.childItems);
                newItem.setSubMenu(subMenu);
            }
        }
    }

    private CustomMenuItem addMenuItemToMenu(VMenuBar menuToAddTo,
            final MenuItemState menuItemState) {
        String itemText = buildItemHTML(menuItemState,
                getState().htmlContentAllowed, getConnection());
        CustomMenuItem item = menuToAddTo.addItem(itemText, new Command() {
            @Override
            public void execute() {
                if (contextMenuWidget.isAttached()) {
                    dummyRootMenuBar.hideChildren();
                    itemSelected(menuItemState.id);
                }
            }
        });

        updateMenuItemFromState(item, menuItemState);

        return item;
    }

    private void updateMenuItemFromState(CustomMenuItem item,
            MenuItemState state) {
        item.setEnabled(state.enabled);
        item.setCheckable(state.checkable);
        item.setChecked(state.checked);
        item.setStyleName(state.styleName);
        if (item instanceof VMenuItem) { // TODO: when these are added, the
                                         // condition must be removed
            ((VMenuItem) item).setSeparator(state.separator);
            ((VMenuItem) item).setDescription(state.description);
        }
    }

    // TODO adapted from VMenuBar.buildItemHTML, must be removed/refactored asap
    private static String buildItemHTML(MenuItemState state,
            boolean htmlContentAllowed, ApplicationConnection connection) {
        // Construct html from the text and the optional icon
        StringBuffer itemHTML = new StringBuffer();
        if (state.separator) {
            itemHTML.append("<span>---</span>");
        } else {
            // Add submenu indicator
            if (state.childItems != null && state.childItems.size() > 0) {
                itemHTML.append(
                        "<span class=\"v-menubar-submenu-indicator\">&#x25BA;</span>");
            }

            itemHTML.append("<span class=\"v-menubar-menuitem-caption\">");

            final String iconUrl = state.icon.getURL();
            // >>> This is the Magnolia IconFont patch. (MGNLUI-1323)
            String ICON_FONT_CODE = "iconfont#";
            if (iconUrl.startsWith(ICON_FONT_CODE)) {
                SpanElement iconFont;
                iconFont = Document.get().createSpanElement();
                String iconFontCssClass = iconUrl.substring(ICON_FONT_CODE.length());
                iconFont.setClassName("v-icon " + iconFontCssClass);
                itemHTML.append(iconFont.getString());
            }
            else {
                Icon icon = connection.getIcon(iconUrl);
                if (icon != null) {
                    itemHTML.append(icon.getElement().getString());
                }
            }

            String itemText = state.text;
            if (!htmlContentAllowed) {
                itemText = WidgetUtil.escapeHTML(itemText);
            }
            itemHTML.append(itemText);
            itemHTML.append("</span>");
        }
        return itemHTML.toString();
    }

    protected void itemSelected(int id) {
        getRpcProxy(ContextMenuServerRpc.class).itemClicked(id, true);
    }

    private void showMenu(int eventX, int eventY) {
        CustomMenuItem firstItem = dummyRootMenuBar.getItems().get(0);
        dummyRootMenuBar.setSelected(firstItem);
        dummyRootMenuBar.showChildMenuAt(firstItem, eventY, eventX);
    }

    @Override
    protected void extend(ServerConnector target) {
        Logger.getLogger("ContextMenuConnector").info("extend");

        // Widget widget = ((AbstractComponentConnector) target).getWidget();

        // widget.addDomHandler(new ContextMenuHandler() {
        //
        // @Override
        // public void onContextMenu(ContextMenuEvent event) {
        // event.stopPropagation();
        // event.preventDefault();
        //
        // showMenu(event.getNativeEvent().getClientX(), event
        // .getNativeEvent().getClientY());
        // }
        // }, ContextMenuEvent.getType());

        // widget.addDomHandler(new KeyDownHandler() {
        // @Override
        // public void onKeyDown(KeyDownEvent event) {
        // // FIXME: check if menu is shown or handleNavigation will do it?
        //
        // boolean handled = contextMenuWidget.handleNavigation(event
        // .getNativeEvent().getKeyCode(), event.getNativeEvent()
        // .getCtrlKey(), event.getNativeEvent().getShiftKey());
        //
        // if (handled) {
        // event.stopPropagation();
        // event.preventDefault();
        // }
        // }
        // }, KeyDownEvent.getType());
    }
}