javafx-8 - 当阶段被模式阶段禁用时，JavaFX8 中是否有事件？

Question

我正在尝试为我们的项目创建一个状态栏。我想要发生的是每当主阶段被模式阶段(例如对话框)禁用时更改状态栏消息。

它目前是通过在显示模态阶段之前和之后手动更改状态消息来实现的。有一个更好的方法吗？

Answer 1

有一种非常简单的方法可以做到这一点，假设您只有一个对话框:

statusLabel.textProperty().bind(Bindings.when(dialog.showingProperty())
     .then("Modal Dialog is showing").otherwise("Main window is showing"));

或者，如果您有多个对话框，您可以执行以下操作:

List<Stage> dialogs = ...
statusLabel.textProperty().bind(new StringBinding() {
    {
        for (Stage dialog : dialogs)
            bind(dialog.showingProperty());
    }
    protected String computeValue() {
        for (Stage dialog : dialogs)
            if (dialog.isShowing())
                return "A modal dialog is showing";
        return "Main window is showing";
    }
});

编辑:目前，没有简单的方法来确定给定的窗口是否被另一个模态窗口阻止，假设您不知道(或不想跟踪)您创建的所有子窗口.另外，如果您使用的是 FileChooser或 DirectoryChooser ，上述方法完全失效。

但是，通过将自定义 Toolkit 插入 javafx，您可以获得所需的行为。警告:直接在代码中使用 com.sun.* 中的类通常不是一个好主意。但是本着冒险精神，我已经实现了一个这样的工具包(我相信)它可以正常工作。它应该适用于 WINDOW_MODAL和 APPLICATION_MODAL视窗。使用风险自负!开始:

public class Test extends Application {

    public static final StringProperty readyLabelProperty = new SimpleStringProperty("Ready");
    public static final StringProperty blockedLabelProperty = new SimpleStringProperty("Blocked");

    public static void main(String[] args) {
        Tk.register();
        Application.launch(args);
    }

    private static StringBinding statusBinding(Window window) {
        return Bindings.when(Tk.blockedProperty(window)).then(blockedLabelProperty).otherwise(readyLabelProperty);
    }

    @Override
    public void start(Stage s) throws Exception {
        s.show();
        s.titleProperty().bind(statusBinding(s));

        Stage stage = new Stage();
        stage.initOwner(s);
        stage.initModality(Modality.WINDOW_MODAL);
        stage.titleProperty().bind(statusBinding(stage));
        stage.show();

        new FileChooser().showOpenDialog(stage);
    }
}

public class Tk extends Toolkit {

    public static final BooleanBinding blockedProperty(final Window window) {
        Objects.requireNonNull(window);
        return new BooleanBinding() {
            {
                bind(stageImpls, owners);
            }
            @Override
            protected boolean computeValue() {
                try {
                    return StageImpl.get(window).isBlocked();
                } catch (NullPointerException e) {
                    return false;
                }
            }
        };
    }

    private static final Field TOOLKIT = getField(Toolkit.class, "TOOLKIT");

    private static Field getField(Class<?> clazz, String name) {
        try {
            Field f = clazz.getDeclaredField(name);
            f.setAccessible(true);
            return f;
        } catch (NoSuchFieldException e) {
            return getField(clazz.getSuperclass(), name);
        }
    }

    private static Method getMethod(Class<?> clazz, String name, Class<?>...parameterTypes) {
        try {
            Method m = clazz.getDeclaredMethod(name, parameterTypes);
            m.setAccessible(true);
            return m;
        } catch (NoSuchMethodException e) {
            return getMethod(clazz.getSuperclass(), name);
        }
    }

    private static final Object invoke(Method method, Object obj, Object...args) {
        try {
            return method.invoke(obj, args);
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

    private final Toolkit qt = Toolkit.getToolkit();
    private static Tk current;

    public static void register() {
        current = new Tk();
        rewrap();
    }

    private static void unwrap() {
        current = (Tk)Toolkit.getToolkit();
        try {
            TOOLKIT.set(null, current.qt);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    private static void rewrap() {
        try {
            TOOLKIT.set(null, Objects.requireNonNull(current));
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    private static final ObservableList<StageImpl> owners = FXCollections.observableArrayList();
    private static final ObservableList<StageImpl> stageImpls = new ModifiableObservableListBase<StageImpl>() {
        final ArrayList<StageImpl> list = new ArrayList<>();
        final InvalidationListener l = new InvalidationListener() {
            public void invalidated(Observable obs) {
                beginChange(); 
                nextUpdate(indexOf(StageImpl.get((Window)((ReadOnlyBooleanProperty)obs).getBean())));
                endChange();
            }
        };
        public StageImpl get(int index) {
            return list.get(index);
        }
        public int size() {
            return list.size();
        }
        protected void doAdd(int index, StageImpl element) {
            list.add(index, element);
            element.peer.showingProperty().addListener(l);
        }
        protected StageImpl doSet(int index, StageImpl element) {
            StageImpl replaced = list.set(index, element);
            replaced.peer.showingProperty().removeListener(l);
            element.peer.showingProperty().addListener(l);
            return replaced;
        }
        protected StageImpl doRemove(int index) {
            StageImpl removed = list.remove(index);
            removed.peer.showingProperty().removeListener(l);
            return removed;
        }
    };

    public TKStage createTKStage(Window w, StageStyle s, boolean primary, Modality m, TKStage owner, boolean rtl, AccessControlContext acc) {
        return new StageImpl(qt.createTKStage(w, s, primary, m, owner == null ? null : StageImpl.get(owner).qs, rtl, acc), w, owner, m);
    }

    public FileChooserResult showFileChooser(TKStage owner, String title, File dir, String name, FileChooserType type,
            List<ExtensionFilter> filters, ExtensionFilter selected) {
        if (owner == null)
            return qt.showFileChooser(null, title, dir, name, type, filters, selected);
        StageImpl ownerImpl = StageImpl.get(owner);
        owners.add(ownerImpl);
        FileChooserResult result = qt.showFileChooser(ownerImpl.qs, title, dir, name, type, filters, selected);
        owners.remove(ownerImpl);
        return result;
    }

    public File showDirectoryChooser(TKStage owner, String title, File dir) {
        if (owner == null)
            return qt.showDirectoryChooser(null, title, dir);
        StageImpl ownerImpl = StageImpl.get(owner);
        owners.add(ownerImpl);
        File file = qt.showDirectoryChooser(ownerImpl.qs, title, dir);
        owners.remove(ownerImpl);
        return file;
    }
    public boolean init() {
        return qt.init();
    }
    public void startup(Runnable userStartupRunnable) {
        qt.startup(userStartupRunnable);
    }
    public void checkFxUserThread() {
        qt.checkFxUserThread();
    }
    public Future<?> addRenderJob(RenderJob r) {
        return qt.addRenderJob(r);
    }
    public AppletWindow createAppletWindow(long parent, String serverName) {
        return qt.createAppletWindow(parent, serverName);
    }
    public void closeAppletWindow() {
        qt.closeAppletWindow();
    }
    public Object enterNestedEventLoop(Object key) {
        return qt.enterNestedEventLoop(key);
    }
    public void exitNestedEventLoop(Object key, Object rval) {
        qt.exitNestedEventLoop(key, rval);
    }
    public TKStage createTKPopupStage(Window peerWindow, StageStyle popupStyle,
            TKStage owner, AccessControlContext acc) {
        return qt.createTKPopupStage(peerWindow, popupStyle, owner, acc);
    }
    public TKStage createTKEmbeddedStage(HostInterface host,
            AccessControlContext acc) {
        return qt.createTKEmbeddedStage(host, acc);
    }
    public ScreenConfigurationAccessor setScreenConfigurationListener(
            TKScreenConfigurationListener listener) {
        return qt.setScreenConfigurationListener(listener);
    }
    public Object getPrimaryScreen() {
        return qt.getPrimaryScreen();
    }
    public List<?> getScreens() {
        return qt.getScreens();
    }
    public PerformanceTracker getPerformanceTracker() {
        return qt.getPerformanceTracker();
    }
    public PerformanceTracker createPerformanceTracker() {
        return qt.createPerformanceTracker();
    }
    public ImageLoader loadImage(String url, int width, int height,
            boolean preserveRatio, boolean smooth) {
        return qt.loadImage(url, width, height, preserveRatio, smooth);
    }
    public ImageLoader loadImage(InputStream stream, int width, int height,
            boolean preserveRatio, boolean smooth) {
        return qt.loadImage(stream, width, height, preserveRatio, smooth);
    }
    public AbstractRemoteResource loadImageAsync(
            AsyncOperationListener l, String url, int width, int height,
            boolean preserveRatio, boolean smooth) {
        return (AbstractRemoteResource) qt.loadImageAsync(l, url, width, height,
                preserveRatio, smooth);
    }
    public void defer(Runnable runnable) {
        qt.defer(runnable);
    }
    public void exit() {
        qt.exit();
    }
    public boolean isForwardTraversalKey(KeyEvent e) {
        return qt.isForwardTraversalKey(e);
    }
    public boolean isBackwardTraversalKey(KeyEvent e) {
        return qt.isBackwardTraversalKey(e);
    }
    public Map<Object, Object> getContextMap() {
        return qt.getContextMap();
    }
    public int getRefreshRate() {
        return qt.getRefreshRate();
    }
    public void setAnimationRunnable(DelayedRunnable animationRunnable) {
        qt.setAnimationRunnable(animationRunnable);
    }
    public void requestNextPulse() {
        qt.requestNextPulse();
    }
    public void waitFor(Task t) {
        qt.waitFor(t);
    }
    public void accumulateStrokeBounds(Shape s, float[] b, StrokeType t, double w, StrokeLineCap c, StrokeLineJoin j, float m, BaseTransform tx) {
        qt.accumulateStrokeBounds(s, b, t, w, c, j, m, tx);
    }
    public boolean strokeContains(Shape s, double x, double y, StrokeType t, double w, StrokeLineCap c, StrokeLineJoin j, float m) {
        return qt.strokeContains(s, x, y, t, w, c, j, m);
    }
    public Shape createStrokedShape(Shape s, StrokeType p, double w, StrokeLineCap c, StrokeLineJoin j, float l, float[] d, float o) {
        return qt.createStrokedShape(s, p, w, c, j, l, d, o);
    }
    public Dimension2D getBestCursorSize(int w, int h) {
        return qt.getBestCursorSize(w, h);
    }
    public int getMaximumCursorColors() {
        return qt.getMaximumCursorColors();
    }
    public int getKeyCodeForChar(String c) {
        return qt.getKeyCodeForChar(c);
    }
    public PathElement[] convertShapeToFXPath(Object s) {
        return qt.convertShapeToFXPath(s);
    }
    public HitInfo convertHitInfoToFX(Object hit) {
        return qt.convertHitInfoToFX(hit);
    }
    public Filterable toFilterable(Image img) {
        return qt.toFilterable(img);
    }
    public FilterContext getFilterContext(Object c) {
        return qt.getFilterContext(c);
    }
    public AbstractMasterTimer getMasterTimer() {
        return qt.getMasterTimer();
    }
    public FontLoader getFontLoader() {
        return qt.getFontLoader();
    }
    public TextLayoutFactory getTextLayoutFactory() {
        return qt.getTextLayoutFactory();
    }
    public Object createSVGPathObject(SVGPath s) {
        return qt.createSVGPathObject(s);
    }
    public Path2D createSVGPath2D(SVGPath s) {
        return qt.createSVGPath2D(s);
    }
    public boolean imageContains(Object image, float x, float y) {
        return qt.imageContains(image, x, y);
    }
    public boolean isNestedLoopRunning() {
        return qt.isNestedLoopRunning();
    }
    public boolean isSupported(ConditionalFeature f) {
        return qt.isSupported(f);
    }
    public boolean isAntiAliasingSupported() {
        return qt.isAntiAliasingSupported();
    }
    public TKClipboard getSystemClipboard() {
        return qt.getSystemClipboard();
    }
    public TKSystemMenu getSystemMenu() {
        return qt.getSystemMenu();
    }
    public TKClipboard getNamedClipboard(String name) {
        return qt.getNamedClipboard(name);
    }
    public void startDrag(TKScene s, Set<TransferMode> tm, TKDragSourceListener l, Dragboard d) {
        qt.startDrag(SceneImpl.get(s).qs, tm, l, d);
    }
    public void enableDrop(TKScene s, TKDropTargetListener l) {
        qt.enableDrop(SceneImpl.get(s).qs, l);
    }
    public void registerDragGestureListener(TKScene s, Set<TransferMode> tm, TKDragGestureListener l) {
        qt.registerDragGestureListener(SceneImpl.get(s).qs, tm, l);
    }
    public void installInputMethodRequests(TKScene s, InputMethodRequests requests) {
        qt.installInputMethodRequests(SceneImpl.get(s).qs, requests);
    }
    public ImageLoader loadPlatformImage(Object platformImage) {
        return qt.loadPlatformImage(platformImage);
    }
    public PlatformImage createPlatformImage(int w, int h) {
        return qt.createPlatformImage(w, h);
    }
    public Object renderToImage(ImageRenderingContext p) {
        return qt.renderToImage(p);
    }
    public long getMultiClickTime() {
        return qt.getMultiClickTime();
    }
    public int getMultiClickMaxX() {
        return qt.getMultiClickMaxX();
    }
    public int getMultiClickMaxY() {
        return qt.getMultiClickMaxY();
    }
    protected Object createColorPaint(Color paint) {
        throw new UnsupportedOperationException();
    }
    protected Object createLinearGradientPaint(LinearGradient paint) {
        throw new UnsupportedOperationException();
    }
    protected Object createRadialGradientPaint(RadialGradient paint) {
        throw new UnsupportedOperationException();
    }
    protected Object createImagePatternPaint(ImagePattern paint) {
        throw new UnsupportedOperationException();
    }
    public boolean isFxUserThread() {
        return qt.isFxUserThread();
    }
    public String toString() {
        return qt.toString();
    }
    public void firePulse() {
        qt.firePulse();
    }
    public void addStageTkPulseListener(TKPulseListener l) {
        qt.addStageTkPulseListener(l);
    }
    public void removeStageTkPulseListener(TKPulseListener l) {
        qt.removeStageTkPulseListener(l);
    }
    public void addSceneTkPulseListener(TKPulseListener l) {
        qt.addSceneTkPulseListener(l);
    }
    public void removeSceneTkPulseListener(TKPulseListener l) {
        qt.removeSceneTkPulseListener(l);
    }
    public void addPostSceneTkPulseListener(TKPulseListener l) {
        qt.addPostSceneTkPulseListener(l);
    }
    public void removePostSceneTkPulseListener(TKPulseListener l) {
        qt.removePostSceneTkPulseListener(l);
    }
    public void addTkListener(TKListener l) {
        qt.addTkListener(l);
    }
    public void removeTkListener(TKListener l) {
        qt.removeTkListener(l);
    }
    public void setLastTkPulseListener(TKPulseListener l) {
        qt.setLastTkPulseListener(l);
    }
    public void addShutdownHook(Runnable hook) {
        qt.addShutdownHook(hook);
    }
    public void removeShutdownHook(Runnable hook) {
        qt.removeShutdownHook(hook);
    }
    public void notifyWindowListeners(List<TKStage> windows) {
        qt.notifyWindowListeners(windows);
    }
    public void notifyLastNestedLoopExited() {
        qt.notifyLastNestedLoopExited();
    }
    public InputStream getInputStream(String url, Class base) throws IOException {
        return qt.getInputStream(url, base);
    }
    public boolean getDefaultImageSmooth() {
        return qt.getDefaultImageSmooth();
    }
    public Object getPaint(Paint paint) {
        return qt.getPaint(paint);
    }
    public TKClipboard createLocalClipboard() {
        return qt.createLocalClipboard();
    }
    public void stopDrag(Dragboard dragboard) {
        qt.stopDrag(dragboard);
    }
    public Color4f toColor4f(Color color) {
        return qt.toColor4f(color);
    }
    public ShadowMode toShadowMode(BlurType blurType) {
        return qt.toShadowMode(blurType);
    }
    public KeyCode getPlatformShortcutKey() {
        return qt.getPlatformShortcutKey();
    }
    public void pauseScenes() {
        qt.pauseScenes();
    }
    public void resumeScenes() {
        qt.resumeScenes();
    }
    public void pauseCurrentThread() {
        qt.pauseCurrentThread();
    }
    public Set<HighlightRegion> getHighlightedRegions() {
        return qt.getHighlightedRegions();
    }

    static final class StageImpl implements TKStage {

        final TKStage qs;
        final Window peer;
        final StageImpl owner;
        final Modality modality;

        boolean isBlocked() {
            for (StageImpl w : owners)
                if (w == this || w.isDescendantOf(this))
                    return true;
            for (StageImpl w : stageImpls) {
                if (w.peer.isShowing()) {
                    switch (w.modality) {
                    case APPLICATION_MODAL:
                        if (w != this && !this.isDescendantOf(w))
                            return true;
                    case WINDOW_MODAL:
                        if (w.isDescendantOf(this))
                            return true;
                    default:
                    }
                }
            }
            return false;
        }
        StageImpl(TKStage quantumStage, Window peer, TKStage owner, Modality modality) {
            if (quantumStage instanceof StageImpl || map.containsKey(quantumStage))
                throw new IllegalArgumentException();
            this.owner = owner == null ? null : get(owner);
            this.modality = modality == null ? Modality.NONE : modality;
            map.put(this.qs = Objects.requireNonNull(quantumStage), this);
            if (peers.containsKey(peer))
                peers.get(peer).dispose();
            peers.put(this.peer = Objects.requireNonNull(peer), this);
            stageImpls.add(this);
        }
        boolean isDescendantOf(StageImpl possibleAncestor) {
            for (StageImpl stage = owner; stage != null; stage = stage.owner)
                if (stage == possibleAncestor)
                    return true;
            return false;
        }
        private static final HashMap<TKStage, StageImpl> map = new HashMap<>();
        private static final HashMap<Window, StageImpl> peers = new HashMap<>();
        static final StageImpl get(TKStage stage) {
            if (Objects.requireNonNull(stage) instanceof StageImpl)
                return (StageImpl) stage;
            return Objects.requireNonNull(map.get(stage));
        }
        static final StageImpl get(Window peer) {
            return peers.get(Objects.requireNonNull(peer));
        }
        public void dispose() {
            map.remove(qs);
            peers.remove(peer);
            stageImpls.remove(this);
        }
        public void setTKStageListener(TKStageListener listener) {
            qs.setTKStageListener(listener);
        }
        public TKScene createTKScene(boolean depthBuffer, boolean antiAliasing, AccessControlContext acc) {
            return new SceneImpl(qs.createTKScene(depthBuffer, antiAliasing, acc));
        }
        public void setScene(TKScene scene) {
            qs.setScene(scene == null ? null : SceneImpl.get(scene).qs);
        }
        public void setBounds(float x, float y, boolean xSet, boolean ySet, float w, float h, float cw, float ch, float xGravity, float yGravity) {
            qs.setBounds(x, y, xSet, ySet, w, h, cw, ch, xGravity, yGravity);
        }
        public void setIcons(List icons) {
            qs.setIcons(icons);
        }
        public void setTitle(String title) {
            qs.setTitle(title);
        }
        public void setVisible(boolean visible) {
            qs.setVisible(visible);
        }
        public void setOpacity(float opacity) {
            qs.setOpacity(opacity);
        }
        public void setIconified(boolean iconified) {
            qs.setIconified(iconified);
        }
        public void setMaximized(boolean maximized) {
            qs.setMaximized(maximized);
        }
        public void setResizable(boolean resizable) {
            qs.setResizable(resizable);
        }
        public void setImportant(boolean important) {
            qs.setImportant(important);
        }
        public void setMinimumSize(int w, int h) {
            qs.setMinimumSize(w, h);
        }
        public void setMaximumSize(int w, int h) {
            qs.setMaximumSize(w, h);
        }
        public void setFullScreen(boolean f) {
            qs.setFullScreen(f);
        }
        public void requestFocus() {
            qs.requestFocus();
        }
        public void toBack() {
            qs.toBack();
        }
        public void toFront() {
            qs.toFront();
        }
        public void close() {
            qs.close();
        }
        public void requestFocus(FocusCause cause) {
            qs.requestFocus(cause);
        }
        public boolean grabFocus() {
            return qs.grabFocus();
        }
        public void ungrabFocus() {
            qs.ungrabFocus();
        }
        public void requestInput(String text, int type, double width,
                double height, double Mxx, double Mxy, double Mxz, double Mxt,
                double Myx, double Myy, double Myz, double Myt, double Mzx,
                double Mzy, double Mzz, double Mzt) {
            qs.requestInput(text, type, width, height, Mxx, Mxy, Mxz,
                    Mxt, Myx, Myy, Myz, Myt, Mzx, Mzy, Mzz, Mzt);
        }
        public void releaseInput() {
            qs.releaseInput();
        }
        public void setRTL(boolean b) {
            qs.setRTL(b);
        }
        public void setAccessibilityInitIsComplete(Object ac) {
            qs.setAccessibilityInitIsComplete(ac);
        }
        public Object accessibleCreateStageProvider(AccessibleStageProvider ac) {
            return qs.accessibleCreateStageProvider(ac);
        }
        public Object accessibleCreateBasicProvider(AccessibleProvider ac) {
            return qs.accessibleCreateBasicProvider(ac);
        }
        public void accessibleDestroyBasicProvider(Object a) {
            qs.accessibleDestroyBasicProvider(a);
        }
        public void accessibleFireEvent(Object a, int eventID) {
            qs.accessibleFireEvent(a, eventID);
        }
        public void accessibleFirePropertyChange(Object a, int p, int o, int n) {
            qs.accessibleFirePropertyChange(a, p, o, n);
        }
        public void accessibleFirePropertyChange(Object a, int p, boolean o, boolean n) {
            qs.accessibleFirePropertyChange(a, p, o, n);
        }
    }

    static final class SceneImpl implements TKScene {

        public final TKScene qs;

        public SceneImpl(TKScene quantumScene) {
            if (quantumScene instanceof SceneImpl || map.containsKey(quantumScene))
                throw new IllegalArgumentException();
            map.put(this.qs = Objects.requireNonNull(quantumScene), this);
            Method getPlatformView = getMethod(quantumScene.getClass(), "getPlatformView");
            View view = (View)invoke(getPlatformView, quantumScene);
            view.setEventHandler(new VEHImpl(view.getEventHandler()));      
        }

        private static final HashMap<TKScene, SceneImpl> map = new HashMap<>();

        public static final SceneImpl get(TKScene scene) {
            if (Objects.requireNonNull(scene) instanceof SceneImpl)
                return (SceneImpl) scene;
            return Objects.requireNonNull(map.get(scene));
        }
        public void dispose() {
            map.remove(qs);
            qs.dispose();
        }
        public void waitForRenderingToComplete() {
            qs.waitForRenderingToComplete();
        }
        public void waitForSynchronization() {
            qs.waitForSynchronization();
        }
        public void releaseSynchronization(boolean u) {
            qs.releaseSynchronization(u);
        }
        public void setTKSceneListener(TKSceneListener l) {
            qs.setTKSceneListener(l);
        }
        public void setTKScenePaintListener(TKScenePaintListener l) {
            qs.setTKScenePaintListener(l);
        }
        public void setRoot(NGNode root) {
            qs.setRoot(root);
        }
        public void markDirty() {
            qs.markDirty();
        }
        public void setCamera(NGCamera camera) {
            qs.setCamera(camera);
        }
        public NGLightBase[] getLights() {
            return qs.getLights();
        }
        public void setLights(NGLightBase[] lights) {
            qs.setLights(lights);
        }
        public void setFillPaint(Object f) {
            qs.setFillPaint(f);
        }
        public void setCursor(Object cursor) {
            qs.setCursor(cursor);
        }
        public void enableInputMethodEvents(boolean enable) {
            qs.enableInputMethodEvents(enable);
        }
        public void finishInputMethodComposition() {
            qs.finishInputMethodComposition();
        }
        public void entireSceneNeedsRepaint() {
            qs.entireSceneNeedsRepaint();
        }
        public TKClipboard createDragboard(boolean d) {
            return qs.createDragboard(d);
        }

    }

    static final class VEHImpl extends EventHandler {

        private final EventHandler qh;

        public VEHImpl(EventHandler quantumHandler) {
            this.qh = quantumHandler;
        }
        public void handleViewEvent(View view, long time, int type) {
            unwrap();
            qh.handleViewEvent(view, time, type);
            rewrap();
        }
        public void handleKeyEvent(View view, long time, int action, int keyCode,char[] keyChars, int m) {
            qh.handleKeyEvent(view, time, action, keyCode, keyChars, m);
        }
        public void handleMenuEvent(View view, int x, int y, int xAbs, int yAbs,boolean k) {
            qh.handleMenuEvent(view, x, y, xAbs, yAbs,k);
        }
        public void handleMouseEvent(View view, long time, int type, int button,int x, int y, int xAbs, int yAbs, int m,boolean p, boolean s) {
            qh.handleMouseEvent(view, time, type, button, x, y, xAbs,yAbs, m, p, s);
        }
        public void handleScrollEvent(View view, long time, int x, int y, int xAbs,int yAbs, double deltaX, double deltaY, int m, int lines,int chars, int l, int c, double xm,double ym) {
            qh.handleScrollEvent(view, time, x, y, xAbs, yAbs, deltaX, deltaY, m, lines, chars, l, c,xm, ym);
        }
        public void handleInputMethodEvent(long time, String text, int[] c, int[] a, byte[] v, int cc, int p) {
            qh.handleInputMethodEvent(time, text, c, a, v, cc, p);
        }
        public double[] getInputMethodCandidatePos(int offset) {
            return qh.getInputMethodCandidatePos(offset);
        }
        public void handleDragStart(View view, int button, int x, int y, int xAbs, int yAbs, ClipboardAssistance d) {
            qh.handleDragStart(view, button, x, y, xAbs, yAbs, d);
        }
        public void handleDragEnd(View view, int p) {
            qh.handleDragEnd(view, p);
        }
        public int handleDragEnter(View view, int x, int y, int xAbs, int yAbs, int r, ClipboardAssistance d) {
            return qh.handleDragEnter(view, x, y, xAbs, yAbs, r, d);
        }
        public int handleDragOver(View view, int x, int y, int xAbs, int yAbs, int r, ClipboardAssistance d) {
            return qh.handleDragOver(view, x, y, xAbs, yAbs, r, d);
        }
        public void handleDragLeave(View view, ClipboardAssistance d) {
            qh.handleDragLeave(view, d);
        }
        public int handleDragDrop(View view, int x, int y, int xAbs, int yAbs, int r, ClipboardAssistance d) {
            return qh.handleDragDrop(view, x, y, xAbs, yAbs, r, d);
        }
        public void handleBeginTouchEvent(View view, long time, int m, boolean isDirect, int tc) {
            qh.handleBeginTouchEvent(view, time, m, isDirect, tc);
        }
        public void handleNextTouchEvent(View view, long time, int type, long touchId, int x, int y, int xAbs, int yAbs) {
            qh.handleNextTouchEvent(view, time, type, touchId, x, y, xAbs, yAbs);
        }
        public void handleEndTouchEvent(View view, long time) {
            qh.handleEndTouchEvent(view, time);
        }
        public void handleScrollGestureEvent(View v, long t, int type, int m, boolean d, boolean i, int c, int x, int y, int xAbs, int yAbs, double dx, double dy, double tdx, double tdy, double mx, double my) {
            qh.handleScrollGestureEvent(v, t, type, m, d, i, c, x, y, xAbs, yAbs, dx, dy, tdx, tdy, mx, my);
        }
        public void handleZoomGestureEvent(View v, long t, int type, int m, boolean d, boolean i, int x, int y, int xAbs, int yAbs, double scale, double e, double s, double te) {
            qh.handleZoomGestureEvent(v, t, type, m, d, i, x, y, xAbs, yAbs, scale, e, s, te);
        }
        public void handleRotateGestureEvent(View v, long t, int type, int m, boolean d, boolean i, int x, int y, int xAbs, int yAbs, double dangle, double a) {
            qh.handleRotateGestureEvent(v, t, type, m, d, i, x, y, xAbs, yAbs, dangle, a);
        }
        public void handleSwipeGestureEvent(View v, long t, int type, int m, boolean d, boolean i, int c, int dir, int x, int y, int xAbs, int yAbs) {
            qh.handleSwipeGestureEvent(v, t, type, m, d, i, c, dir, x, y, xAbs, yAbs);
        }
    }
}