mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
293 lines
9.8 KiB
Java
293 lines
9.8 KiB
Java
/* -*- Mode: Java; c-basic-offset: 4; tab-width: 20; indent-tabs-mode: nil; -*-
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is Mozilla Android code.
|
|
*
|
|
* The Initial Developer of the Original Code is Mozilla Foundation.
|
|
* Portions created by the Initial Developer are Copyright (C) 2009-2010
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Patrick Walton <pcwalton@mozilla.com>
|
|
* Arkady Blyakher <rkadyb@mit.edu>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
package org.mozilla.gecko.gfx;
|
|
|
|
import org.mozilla.gecko.GeckoAppShell;
|
|
import org.mozilla.gecko.GeckoInputConnection;
|
|
import org.mozilla.gecko.gfx.FloatSize;
|
|
import org.mozilla.gecko.gfx.InputConnectionHandler;
|
|
import org.mozilla.gecko.gfx.LayerController;
|
|
import android.content.Context;
|
|
import android.opengl.GLSurfaceView;
|
|
import android.view.View;
|
|
import android.view.KeyEvent;
|
|
import android.view.MotionEvent;
|
|
import android.view.inputmethod.EditorInfo;
|
|
import android.view.inputmethod.InputConnection;
|
|
import android.widget.RelativeLayout;
|
|
import android.util.Log;
|
|
import java.nio.IntBuffer;
|
|
|
|
import org.mozilla.gecko.GeckoApp;
|
|
import android.content.Context;
|
|
import android.graphics.PixelFormat;
|
|
import android.opengl.GLSurfaceView;
|
|
import android.util.AttributeSet;
|
|
import android.view.SurfaceHolder;
|
|
import android.view.SurfaceView;
|
|
import javax.microedition.khronos.opengles.GL10;
|
|
|
|
|
|
/**
|
|
* A view rendered by the layer compositor.
|
|
*
|
|
* This view delegates to LayerRenderer to actually do the drawing. Its role is largely that of a
|
|
* mediator between the LayerRenderer and the LayerController.
|
|
*
|
|
* Note that LayerView is accessed by Robocop via reflection.
|
|
*/
|
|
public class LayerView extends SurfaceView implements SurfaceHolder.Callback {
|
|
private static String LOGTAG = "GeckoLayerView";
|
|
|
|
private Context mContext;
|
|
private LayerController mController;
|
|
private TouchEventHandler mTouchEventHandler;
|
|
private GLController mGLController;
|
|
private InputConnectionHandler mInputConnectionHandler;
|
|
private LayerRenderer mRenderer;
|
|
private long mRenderTime;
|
|
private boolean mRenderTimeReset;
|
|
/* Must be a PAINT_xxx constant */
|
|
private int mPaintState = PAINT_NONE;
|
|
|
|
private Listener mListener;
|
|
|
|
/* Flags used to determine when to show the painted surface. The integer
|
|
* order must correspond to the order in which these states occur. */
|
|
public static final int PAINT_NONE = 0;
|
|
public static final int PAINT_BEFORE_FIRST = 1;
|
|
public static final int PAINT_AFTER_FIRST = 2;
|
|
|
|
|
|
public LayerView(Context context, LayerController controller) {
|
|
super(context);
|
|
|
|
SurfaceHolder holder = getHolder();
|
|
holder.addCallback(this);
|
|
holder.setFormat(PixelFormat.RGB_565);
|
|
|
|
mGLController = new GLController(this);
|
|
mContext = context;
|
|
mController = controller;
|
|
mTouchEventHandler = new TouchEventHandler(context, this, mController);
|
|
mRenderer = new LayerRenderer(this);
|
|
mInputConnectionHandler = null;
|
|
|
|
setFocusable(true);
|
|
setFocusableInTouchMode(true);
|
|
}
|
|
|
|
@Override
|
|
public boolean onTouchEvent(MotionEvent event) {
|
|
/** We need to manually hide FormAssistPopup because it is not a regular PopupWindow. */
|
|
if (GeckoApp.mFormAssistPopup != null)
|
|
GeckoApp.mFormAssistPopup.hide();
|
|
|
|
return mTouchEventHandler.handleEvent(event);
|
|
}
|
|
|
|
public LayerController getController() { return mController; }
|
|
public TouchEventHandler getTouchEventHandler() { return mTouchEventHandler; }
|
|
|
|
/** The LayerRenderer calls this to indicate that the window has changed size. */
|
|
public void setViewportSize(IntSize size) {
|
|
mController.setViewportSize(new FloatSize(size));
|
|
}
|
|
|
|
public GeckoInputConnection setInputConnectionHandler() {
|
|
GeckoInputConnection geckoInputConnection = GeckoInputConnection.create(this);
|
|
mInputConnectionHandler = geckoInputConnection;
|
|
return geckoInputConnection;
|
|
}
|
|
|
|
@Override
|
|
public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
|
|
if (mInputConnectionHandler != null)
|
|
return mInputConnectionHandler.onCreateInputConnection(outAttrs);
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyPreIme(int keyCode, KeyEvent event) {
|
|
if (mInputConnectionHandler != null)
|
|
return mInputConnectionHandler.onKeyPreIme(keyCode, event);
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyDown(int keyCode, KeyEvent event) {
|
|
if (mInputConnectionHandler != null)
|
|
return mInputConnectionHandler.onKeyDown(keyCode, event);
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyLongPress(int keyCode, KeyEvent event) {
|
|
if (mInputConnectionHandler != null)
|
|
return mInputConnectionHandler.onKeyLongPress(keyCode, event);
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
|
|
if (mInputConnectionHandler != null)
|
|
return mInputConnectionHandler.onKeyMultiple(keyCode, repeatCount, event);
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyUp(int keyCode, KeyEvent event) {
|
|
if (mInputConnectionHandler != null)
|
|
return mInputConnectionHandler.onKeyUp(keyCode, event);
|
|
return false;
|
|
}
|
|
|
|
public synchronized void requestRender() {
|
|
if (mListener != null) {
|
|
mListener.renderRequested();
|
|
}
|
|
}
|
|
|
|
public void addLayer(Layer layer) {
|
|
mRenderer.addLayer(layer);
|
|
}
|
|
|
|
public void removeLayer(Layer layer) {
|
|
mRenderer.removeLayer(layer);
|
|
}
|
|
|
|
/**
|
|
* Returns the time elapsed between the first call of requestRender() after
|
|
* the last call of getRenderTime(), in nanoseconds.
|
|
*/
|
|
public long getRenderTime() {
|
|
synchronized(this) {
|
|
mRenderTimeReset = false;
|
|
return System.nanoTime() - mRenderTime;
|
|
}
|
|
}
|
|
|
|
public int getMaxTextureSize() {
|
|
return mRenderer.getMaxTextureSize();
|
|
}
|
|
|
|
/** Used by robocop for testing purposes. Not for production use! This is called via reflection by robocop. */
|
|
public IntBuffer getPixels() {
|
|
return mRenderer.getPixels();
|
|
}
|
|
|
|
public void setLayerRenderer(LayerRenderer renderer) {
|
|
mRenderer = renderer;
|
|
}
|
|
|
|
public LayerRenderer getLayerRenderer() {
|
|
return mRenderer;
|
|
}
|
|
|
|
/* paintState must be a PAINT_xxx constant. The state will only be changed
|
|
* if paintState represents a state that occurs after the current state. */
|
|
public void setPaintState(int paintState) {
|
|
if (paintState > mPaintState) {
|
|
Log.d(LOGTAG, "LayerView paint state set to " + paintState);
|
|
mPaintState = paintState;
|
|
}
|
|
}
|
|
|
|
public int getPaintState() {
|
|
return mPaintState;
|
|
}
|
|
|
|
|
|
public LayerRenderer getRenderer() {
|
|
return mRenderer;
|
|
}
|
|
|
|
public void setListener(Listener listener) {
|
|
mListener = listener;
|
|
}
|
|
|
|
public synchronized GLController getGLController() {
|
|
return mGLController;
|
|
}
|
|
|
|
/** Implementation of SurfaceHolder.Callback */
|
|
public synchronized void surfaceChanged(SurfaceHolder holder, int format, int width,
|
|
int height) {
|
|
mGLController.sizeChanged(width, height);
|
|
|
|
if (mListener != null) {
|
|
mListener.surfaceChanged(width, height);
|
|
}
|
|
}
|
|
|
|
/** Implementation of SurfaceHolder.Callback */
|
|
public synchronized void surfaceCreated(SurfaceHolder holder) {
|
|
mGLController.surfaceCreated();
|
|
}
|
|
|
|
/** Implementation of SurfaceHolder.Callback */
|
|
public synchronized void surfaceDestroyed(SurfaceHolder holder) {
|
|
mGLController.surfaceDestroyed();
|
|
|
|
if (mListener != null) {
|
|
mListener.compositionPauseRequested();
|
|
}
|
|
}
|
|
|
|
/** This function is invoked by Gecko (compositor thread) via JNI; be careful when modifying signature. */
|
|
public static GLController registerCxxCompositor() {
|
|
try {
|
|
LayerView layerView = GeckoApp.mAppContext.getLayerController().getView();
|
|
return layerView.getGLController();
|
|
} catch (Exception e) {
|
|
Log.e(LOGTAG, "### Exception! " + e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public interface Listener {
|
|
void renderRequested();
|
|
void compositionPauseRequested();
|
|
void compositionResumeRequested(int width, int height);
|
|
void surfaceChanged(int width, int height);
|
|
}
|
|
|
|
|
|
}
|