Podłączenie zdarzenia GWT do elementu w zewnętrznej ramce iframe

Spodziewam się, że problem polega na tym, że metoda GWT onAttach() nie jest wywoływana, gdy używasz owijania, jak w pierwszym przykładzie. Możesz spróbować użyć metody static wrap w widżecie przycisku. Chociaż aby tego użyć, input musi być typu button. Lub przyjrzyj się implementacji metody wrap. Oto zmodyfikowany kod przy użyciu metody wrap:

Element buttonElement = finder(frameDocument).tag("input").name(buttonElementName).findOne();
Button button = Button.wrap(buttonElement);
HandlerRegistration handlerRegistration = button.addClickHandler(clickHandler);

Po zbadaniu tego dalej, odkryłem, że ramka iframe jest nieistotna. To samo zachowanie nie działa na zwykłym przycisku na stronie hosta.

W zasadzie naprawiłem to używając JSNI do replikacji części mechanizmu obsługi zdarzeń GWT. Następujące utwory:

Element buttonElement = DOM.getElementById("externalButton");
new CustomElementWrapper(buttonElement).addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
        Window.alert("GWT hooked into button");
    }
});

Gdzie CustomElementWrapper jest:

public class CustomElementWrapper extends Widget implements HasClickHandlers {
    private ClickEventManager clickEventManager;

    public CustomElementWrapper(Element theElement) {
        setElement(theElement);
        clickEventManager = new ClickEventManager(theElement);
    }

    public HandlerRegistration addClickHandler(ClickHandler handler) {
        //The 'right' way of doing this would be the code below. However, this doesn't work
        // A bug in GWT?
        //      
        //              return addDomHandler(handler, ClickEvent.getType());
        return clickEventManager.registerClickHandler(handler);
    }


    void invokeClickHandler() {
        clickEventManager.invokeClickHandler();
    }

    public boolean isClickHandlerRegistered() {
        return clickEventManager.isClickHandlerRegistered();
    }
}

Wreszcie, Menedżer ClickEventManager, w którym dzieje się rzeczywista praca, to:

public class ClickEventManager {
private boolean clickHandlerRegistered = false;
private ClickHandler clickHandler;
private Element element;

public ClickEventManager(Element element) {
    this.element = element;
}

public void invokeClickHandler() {
    //This shouldn't really be null but we are bypassing GWT's native event mechanism
    //so we can't create an event
    clickHandler.onClick(null);
}

public boolean isClickHandlerRegistered() {
    return clickHandlerRegistered;
}

HandlerRegistration registerClickHandler(ClickHandler handler) {
    clickHandler = handler;

    if (!clickHandlerRegistered) {
        registerClickHandlerInJS(element);
        clickHandlerRegistered = true;
    }
    return new HandlerRegistration() {
        public void removeHandler() {
            //For now, we don't support the removal of handlers
            throw new UnsupportedOperationException();
        }
    };
}
private native void registerClickHandlerInJS(Element element)/*-{
    element.__clickManager = this;
    element.onclick 
        = function() {
            var cm = this.__clickManager; 
            [email protected]::invokeClickHandler()();
        }
}-*/;
}

Dzięki,

Tin

Może Ci się to przydać:

import com.google.gwt.dom.client.Element;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.HasClickHandlers;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.ui.AbsolutePanel;

public class DirectPanel extends AbsolutePanel implements HasClickHandlers {
        public DirectPanel(Element elem) {
                super(elem.<com.google.gwt.user.client.Element> cast());
                onAttach();
        }

        @Override
        public HandlerRegistration addClickHandler(ClickHandler handler) {
                return addDomHandler(handler, ClickEvent.getType());
        }
}

Wtedy będziesz mógł zrobić dowolne kontenery w kontenery widgetów:

  Element root = Document.get().getElementById("target");
  DirectPanel p = new DirectPanel(root);
  Button register = new Button("Register");
  register.addClickHandler(new ClickHandler() {
    @Override
    public void onClick(ClickEvent event) {
      // ...
    }
  });
  p.add(register);

I powiązać zdarzenia z dowolnymi elementami:

  Element root = Document.get().getElementById("target");
  DirectPanel p = new DirectPanel(root);
  p.addClickHandler(new ClickHandler() {
    @Override
    public void onClick(ClickEvent event) {
      // ...
    }
  });

Szczególnie w Twoim przypadku, spróbuj tego:

IFrameElement frm = Document.get().createIFrameElement();
Document d = frm.getContentDocument();
NodeList<Element> inputs = d.getElementsByTagName("input");
InputElement target = null;
for(int i = 0; i < inputs.getLength(); ++i) {
  Element e = inputs.getItem(0);
  if (e.getNodeName().equals("submit")) {
    target = InputElement.as(e);
    break;
  }
}
if (target != null) {
  DirectPanel p = new DirectPanel(target);
  p.addClickHandler(new ClickHandler() {
    @Override
    public void onClick(ClickEvent event) {
      // TODO Auto-generated method stub
    }
  });
}

Zamiast używać iframes proponuję po prostu złożyć żądanie http z GWT przez com.google.gwt.http.klient.RequestBuilder. Tak:

private void getHtml(String url) {
        RequestBuilder rb = new RequestBuilder(RequestBuilder.GET, url);

        rb.setCallback(new RequestCallback() {

            @Override
            public void onResponseReceived(Request request, Response response) {
                HTMLPanel html = new HTMLPanel(response.getText());

                // Now you have a widget with the requested page
                // thus you may do whatever you want with it.
            }

            @Override
            public void onError(Request request, Throwable exception) {
                Log.error("error " + exception);
            }
        });

        try {
            rb.send();
        } catch (RequestException e) {
          Log.error("error " + e);
        }
    }

Możesz użyć JSNI do ponownego użycia kodu JavaScript. Twój kod javascript wywoła metodę gwt na obiekcie, który rzuci ją w imieniu przycisku w ramce iframe.

Co do tego, dlaczego kod GWT nie działa -- chyba dlatego, że używają jakiejś warstwy na zwykłych zdarzeniach przeglądarki, które prawdopodobnie nie mogą rozciągać się na więcej niż 1 klatkę. Tylko zgaduję. Możesz to zgłosić jako żądanie funkcji / błędu przeciwko zespołowi GWT. Jeśli mam rację, Twój kod wygląda dobrze.

Zobacz moją poprzednią odpowiedź. Niewielka modyfikacja oryginalnego rozwiązania sprawi, że będzie działać.