ParaView-5.0.1: Added the source-tree to ThirdParty-dev and patched as described in the README file

Resolves bug-report http://bugs.openfoam.org/view.php?id=2098

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/AndroidManifest.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- BEGIN_INCLUDE(manifest) -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        package="com.kitware.JavaVTK"
+        android:versionCode="1"
+        android:versionName="1.0">
+
+    <uses-feature android:glEsVersion="0x00020000" />
+
+    <!-- This is the platform API where NativeActivity was introduced. -->
+    <uses-sdk android:minSdkVersion="12" />
+
+    <application android:label="@string/app_name" >
+
+        <activity android:name="JavaVTKActivity"
+                android:label="@string/app_name"
+                android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
+                android:launchMode="singleTask"
+                android:configChanges="orientation|keyboardHidden">
+            <!-- Tell NativeActivity the name of our .so -->
+            <meta-data android:name="android.app.lib_name"
+                    android:value="JavaVTK" />
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
+<!-- END_INCLUDE(manifest) -->

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/CMakeLists.txt

@@ -0,0 +1,88 @@
+cmake_minimum_required(VERSION 2.8)
+project(JavaVTK)
+
+if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+  message(FATAL_ERROR "VTK Android does not support in-source builds :) .")
+endif ()
+
+find_package(VTK COMPONENTS
+  vtkInteractionStyle
+  vtkRenderingOpenGL2
+  vtkRenderingFreeType
+)
+include(${VTK_USE_FILE})
+
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs/${ANDROID_NDK_ABI_NAME})
+message(${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
+add_subdirectory(jni)
+
+# find android
+find_program(ANDROID_EXECUTABLE
+  NAMES android
+  DOC   "The android command-line tool")
+if(NOT ANDROID_EXECUTABLE)
+  message(FATAL_ERROR "Can not find android command line tool: android")
+endif()
+
+configure_file(
+  "${CMAKE_CURRENT_SOURCE_DIR}/AndroidManifest.xml"
+  "${CMAKE_CURRENT_BINARY_DIR}/AndroidManifest.xml"
+  COPYONLY)
+
+configure_file(
+  "${CMAKE_CURRENT_SOURCE_DIR}/ant.properties.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/ant.properties"
+  @ONLY)
+
+add_custom_target(JavaVTK-ant-configure ALL
+  COMMAND "${ANDROID_EXECUTABLE}"
+          update project
+          --name JavaVTK
+          --path "${CMAKE_CURRENT_SOURCE_DIR}"
+          --target "android-${ANDROID_NATIVE_API_LEVEL}"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different
+          "${CMAKE_CURRENT_SOURCE_DIR}/build.xml"
+          "${CMAKE_CURRENT_BINARY_DIR}/build.xml"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different
+          "${CMAKE_CURRENT_SOURCE_DIR}/local.properties"
+          "${CMAKE_CURRENT_BINARY_DIR}/local.properties"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different
+          "${CMAKE_CURRENT_SOURCE_DIR}/project.properties"
+          "${CMAKE_CURRENT_BINARY_DIR}/project.properties"
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different
+          "${CMAKE_CURRENT_SOURCE_DIR}/proguard-project.txt"
+          "${CMAKE_CURRENT_BINARY_DIR}/proguard-project.txt"
+  COMMAND "${CMAKE_COMMAND}" -E remove
+          "${CMAKE_CURRENT_SOURCE_DIR}/build.xml"
+          "${CMAKE_CURRENT_SOURCE_DIR}/local.properties"
+          "${CMAKE_CURRENT_SOURCE_DIR}/project.properties"
+          "${CMAKE_CURRENT_SOURCE_DIR}/proguard-project.txt"
+  WORKING_DIRECTORY
+          "${CMAKE_CURRENT_BINARY_DIR}")
+
+add_dependencies(JavaVTK-ant-configure JavaVTK)
+
+#find ant
+find_program(ANT_EXECUTABLE
+  NAMES ant
+  DOC   "The ant build tool")
+if(NOT ANT_EXECUTABLE)
+  message(FATAL_ERROR "Can not find ant build tool: ant")
+endif()
+
+add_custom_target(JavaVTK-apk-release ALL
+  COMMAND ${ANT_EXECUTABLE}
+          -file "${CMAKE_CURRENT_BINARY_DIR}/build.xml"
+          release)
+add_dependencies(JavaVTK-apk-release
+  JavaVTK-ant-configure
+  JavaVTK)
+
+add_custom_target(JavaVTK-apk-debug ALL
+  COMMAND ${ANT_EXECUTABLE}
+          -file "${CMAKE_CURRENT_BINARY_DIR}/build.xml"
+          debug)
+add_dependencies(JavaVTK-apk-debug
+  JavaVTK-apk-release
+  JavaVTK-ant-configure
+  JavaVTK)

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/ant.properties.in

@@ -0,0 +1,12 @@
+builddir=@CMAKE_CURRENT_BINARY_DIR@
+srcdir=@CMAKE_CURRENT_SOURCE_DIR@
+
+source.dir=${srcdir}/src
+gen.dir=${builddir}/gen
+out.dir=${builddir}/bin
+asset.dir=${builddir}/assets
+resource.absolute.dir=${srcdir}/res
+
+jar.libs.dir=${builddir}/libs
+external.libs.dir=${builddir}/libs
+native.libs.dir=${builddir}/libs

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/jni/CMakeLists.txt

@@ -0,0 +1,13 @@
+include_directories(
+  "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include"
+)
+
+set(sources
+  main.cxx
+)
+
+add_library(JavaVTK SHARED ${sources})
+target_link_libraries(JavaVTK ${VTK_LIBRARIES}
+  android
+  log
+)

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/jni/main.cxx

@@ -0,0 +1,225 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <jni.h>
+#include <errno.h>
+#include <sstream>
+
+#include "vtkNew.h"
+
+#include "vtkActor.h"
+#include "vtkCamera.h"
+#include "vtkConeSource.h"
+#include "vtkDebugLeaks.h"
+#include "vtkGlyph3D.h"
+#include "vtkPolyData.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderer.h"
+#include "vtkSphereSource.h"
+#include "vtkTextActor.h"
+#include "vtkTextProperty.h"
+
+#include "vtkAndroidRenderWindowInteractor.h"
+#include "vtkCommand.h"
+
+#include <android/log.h>
+
+#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "NativeVTK", __VA_ARGS__))
+#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "NativeVTK", __VA_ARGS__))
+
+extern "C" {
+    JNIEXPORT jlong JNICALL Java_com_kitware_JavaVTK_JavaVTKLib_init(JNIEnv * env, jobject obj,  jint width, jint height);
+    JNIEXPORT void JNICALL Java_com_kitware_JavaVTK_JavaVTKLib_render(JNIEnv * env, jobject obj, jlong renWinP);
+    JNIEXPORT void JNICALL Java_com_kitware_JavaVTK_JavaVTKLib_onKeyEvent(JNIEnv * env, jobject obj, jlong udp,
+      jboolean down, jint keyCode, jint metaState, jint repeatCount
+      );
+    JNIEXPORT void JNICALL Java_com_kitware_JavaVTK_JavaVTKLib_onMotionEvent(JNIEnv * env, jobject obj, jlong udp,
+      jint action,
+      jint eventPointer,
+      jint numPtrs,
+      jfloatArray xPos, jfloatArray yPos,
+      jintArray ids, jint metaState);
+};
+
+struct userData
+{
+  vtkRenderWindow *RenderWindow;
+  vtkRenderer *Renderer;
+  vtkAndroidRenderWindowInteractor *Interactor;
+};
+
+// Example of updating text as we go
+class vtkExampleCallback : public vtkCommand
+{
+public:
+  static vtkExampleCallback *New()
+  { return new vtkExampleCallback; }
+  virtual void Execute( vtkObject *caller, unsigned long, void* )
+  {
+  // Update cardinality of selection
+  double *pos = this->Camera->GetPosition();
+  std::ostringstream txt;
+  txt << "Camera positioned at: "
+    << std::fixed
+    << std::setprecision( 2 )
+    << std::setw( 6 )
+    <<  pos[0] << ", "
+    << std::setw( 6 )
+    << pos[1] << ", "
+    << std::setw( 6 )
+    << pos[2];
+  this->Text->SetInput( txt.str().c_str() );
+  }
+
+  vtkExampleCallback()
+    {
+    this->Camera = 0;
+    this->Text = 0;
+    }
+
+  vtkCamera *Camera;
+  vtkTextActor* Text;
+};
+
+/*
+ * Here is where you would setup your pipeline and other normal VTK logic
+ */
+JNIEXPORT jlong JNICALL Java_com_kitware_JavaVTK_JavaVTKLib_init(JNIEnv * env, jobject obj,  jint width, jint height)
+{
+  vtkRenderWindow *renWin = vtkRenderWindow::New();
+  char jniS[4] = {'j','n','i',0};
+  renWin->SetWindowInfo(jniS); // tell the system that jni owns the window not us
+  renWin->SetSize(width,height);
+  vtkNew<vtkRenderer> renderer;
+  renWin->AddRenderer(renderer.Get());
+
+  vtkNew<vtkAndroidRenderWindowInteractor> iren;
+  iren->SetRenderWindow(renWin);
+
+  vtkNew<vtkSphereSource> sphere;
+  sphere->SetThetaResolution(8);
+  sphere->SetPhiResolution(8);
+
+  vtkNew<vtkPolyDataMapper> sphereMapper;
+  sphereMapper->SetInputConnection(sphere->GetOutputPort());
+  vtkNew<vtkActor> sphereActor;
+  sphereActor->SetMapper(sphereMapper.Get());
+
+  vtkNew<vtkConeSource> cone;
+  cone->SetResolution(6);
+
+  vtkNew<vtkGlyph3D> glyph;
+  glyph->SetInputConnection(sphere->GetOutputPort());
+  glyph->SetSourceConnection(cone->GetOutputPort());
+  glyph->SetVectorModeToUseNormal();
+  glyph->SetScaleModeToScaleByVector();
+  glyph->SetScaleFactor(0.25);
+
+  vtkNew<vtkPolyDataMapper> spikeMapper;
+  spikeMapper->SetInputConnection(glyph->GetOutputPort());
+
+  vtkNew<vtkActor> spikeActor;
+  spikeActor->SetMapper(spikeMapper.Get());
+
+  renderer->AddActor(sphereActor.Get());
+  renderer->AddActor(spikeActor.Get());
+  renderer->SetBackground(0.4,0.5,0.6);
+
+  vtkNew<vtkTextActor> ta;
+  ta->SetInput("Droids Rock");
+  ta->GetTextProperty()->SetColor( 0.5, 1.0, 0.0 );
+  ta->SetDisplayPosition(50,50);
+  ta->GetTextProperty()->SetFontSize(32);
+  renderer->AddActor(ta.Get());
+
+  vtkNew<vtkExampleCallback> cb;
+  cb->Camera = renderer->GetActiveCamera();
+  cb->Text = ta.Get();
+  iren->AddObserver( vtkCommand::InteractionEvent, cb.Get() );
+
+  struct userData *foo = new struct userData();
+  foo->RenderWindow = renWin;
+  foo->Renderer = renderer.Get();
+  foo->Interactor = iren.Get();
+
+  return (jlong)foo;
+}
+
+JNIEXPORT void JNICALL Java_com_kitware_JavaVTK_JavaVTKLib_render(JNIEnv * env, jobject obj, jlong udp)
+{
+  struct userData *foo = (userData *)(udp);
+  foo->RenderWindow->SwapBuffersOff(); // android does it
+  foo->RenderWindow->Render();
+  foo->RenderWindow->SwapBuffersOn(); // reset
+}
+
+JNIEXPORT void JNICALL Java_com_kitware_JavaVTK_JavaVTKLib_onKeyEvent(JNIEnv * env, jobject obj, jlong udp,
+  jboolean down, jint keyCode, jint metaState, jint repeatCount)
+{
+  struct userData *foo = (userData *)(udp);
+  foo->Interactor->HandleKeyEvent(down, keyCode, metaState, repeatCount);
+}
+
+JNIEXPORT void JNICALL Java_com_kitware_JavaVTK_JavaVTKLib_onMotionEvent(JNIEnv * env, jobject obj, jlong udp,
+      jint action,
+      jint eventPointer,
+      jint numPtrs,
+      jfloatArray xPos, jfloatArray yPos,
+      jintArray ids, jint metaState)
+{
+  struct userData *foo = (userData *)(udp);
+
+  int xPtr[VTKI_MAX_POINTERS];
+  int yPtr[VTKI_MAX_POINTERS];
+  int idPtr[VTKI_MAX_POINTERS];
+
+  // only allow VTKI_MAX_POINTERS touches right now
+  if (numPtrs > VTKI_MAX_POINTERS)
+    {
+    numPtrs = VTKI_MAX_POINTERS;
+    }
+
+  // fill in the arrays
+  jfloat *xJPtr = env->GetFloatArrayElements(xPos, 0);
+  jfloat *yJPtr = env->GetFloatArrayElements(yPos, 0);
+  jint *idJPtr = env->GetIntArrayElements(ids, 0);
+  for (int i = 0; i < numPtrs; ++i)
+    {
+    xPtr[i] = (int)xJPtr[i];
+    yPtr[i] = (int)yJPtr[i];
+    idPtr[i] = idJPtr[i];
+    }
+  env->ReleaseIntArrayElements(ids, idJPtr, 0);
+  env->ReleaseFloatArrayElements(xPos, xJPtr, 0);
+  env->ReleaseFloatArrayElements(yPos, yJPtr, 0);
+
+  foo->Interactor->HandleMotionEvent(action, eventPointer, numPtrs, xPtr, yPtr, idPtr, metaState);
+}

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">JavaVTK</string>
+</resources>

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/src/com/kitware/JavaVTK/JavaVTKActivity.java

@@ -0,0 +1,62 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.kitware.JavaVTK;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.WindowManager;
+
+import java.io.File;
+
+
+public class JavaVTKActivity extends Activity
+{
+    JavaVTKView mView;
+
+    @Override protected void onCreate(Bundle icicle)
+    {
+    super.onCreate(icicle);
+    mView = new JavaVTKView(getApplication());
+	this.setContentView(mView);
+    }
+
+    @Override protected void onPause()
+    {
+    super.onPause();
+    this.mView.onPause();
+    }
+
+    @Override protected void onResume()
+    {
+    super.onResume();
+    this.mView.onResume();
+    }
+}

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/src/com/kitware/JavaVTK/JavaVTKLib.java

@@ -0,0 +1,59 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.kitware.JavaVTK;
+import android.view.KeyEvent;
+
+
+// Wrapper for native library
+
+public class JavaVTKLib
+{
+
+    static
+    {
+      System.loadLibrary("JavaVTK");
+    }
+
+    /**
+     * @param width the current view width
+     * @param height the current view height
+     */
+     public static native long init(int width, int height);
+     public static native void render(long udp);
+     public static native void onKeyEvent(long udp, boolean down, int keyCode,
+                                          int metaState,
+                                          int repeatCount);
+     public static native void onMotionEvent(long udp,
+        int action,
+        int eventPointer,
+        int numPtrs,
+        float [] xPos, float [] yPos, int [] ids,
+        int metaState);
+}

ParaView-5.0.1/VTK/Examples/Android/JavaVTK/src/com/kitware/JavaVTK/JavaVTKView.java

@@ -0,0 +1,328 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.kitware.JavaVTK;
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+import android.content.Context;
+import android.graphics.PixelFormat;
+import android.opengl.GLSurfaceView;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * A simple GLSurfaceView sub-class that demonstrate how to perform
+ * OpenGL ES 2.0 rendering into a GL Surface. Note the following important
+ * details:
+ *
+ * - The class must use a custom context factory to enable 2.0 rendering.
+ *   See ContextFactory class definition below.
+ *
+ * - The class must use a custom EGLConfigChooser to be able to select
+ *   an EGLConfig that supports 2.0. This is done by providing a config
+ *   specification to eglChooseConfig() that has the attribute
+ *   EGL10.ELG_RENDERABLE_TYPE containing the EGL_OPENGL_ES2_BIT flag
+ *   set. See ConfigChooser class definition below.
+ *
+ * - The class must select the surface's format, then choose an EGLConfig
+ *   that matches it exactly (with regards to red/green/blue/alpha channels
+ *   bit depths). Failure to do so would result in an EGL_BAD_MATCH error.
+ */
+class JavaVTKView extends GLSurfaceView
+{
+    private static String TAG = "JavaVTKView";
+    private Renderer myRenderer;
+
+    public JavaVTKView(Context context)
+    {
+        super(context);
+        setFocusable(true);
+        setFocusableInTouchMode(true);
+
+        this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
+        setEGLContextFactory(new ContextFactory());
+        setEGLConfigChooser(new ConfigChooser(8, 8, 8, 0, 8, 0));
+
+        /* Set the renderer responsible for frame rendering */
+        this.myRenderer = new Renderer();
+        this.setRenderer(myRenderer);
+        this.setRenderMode(RENDERMODE_WHEN_DIRTY);
+    }
+
+    private static class ContextFactory implements GLSurfaceView.EGLContextFactory
+    {
+        private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
+        public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig)
+        {
+            Log.w(TAG, "creating OpenGL ES 2.0 context");
+            checkEglError("Before eglCreateContext", egl);
+            int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
+            EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
+            checkEglError("After eglCreateContext", egl);
+            return context;
+        }
+
+        public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context)
+        {
+            egl.eglDestroyContext(display, context);
+        }
+    }
+
+    private static void checkEglError(String prompt, EGL10 egl)
+    {
+        int error;
+        while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS)
+            {
+            Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
+            }
+    }
+
+    private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser
+    {
+        public ConfigChooser(int r, int g, int b, int a, int depth, int stencil)
+        {
+            mRedSize = r;
+            mGreenSize = g;
+            mBlueSize = b;
+            mAlphaSize = a;
+            mDepthSize = depth;
+            mStencilSize = stencil;
+        }
+
+        /* This EGL config specification is used to specify 2.0 rendering.
+         * We use a minimum size of 4 bits for red/green/blue, but will
+         * perform actual matching in chooseConfig() below.
+         */
+        private static int EGL_OPENGL_ES2_BIT = 4;
+        private static int[] s_configAttribs2 =
+        {
+            EGL10.EGL_RED_SIZE, 4,
+            EGL10.EGL_GREEN_SIZE, 4,
+            EGL10.EGL_BLUE_SIZE, 4,
+            EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+            EGL10.EGL_NONE
+        };
+
+        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display)
+        {
+            // Get the number of minimally matching EGL configurations
+            int[] num_config = new int[1];
+            egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);
+
+            int numConfigs = num_config[0];
+
+            if (numConfigs <= 0)
+                {
+                throw new IllegalArgumentException("No configs match configSpec");
+                }
+
+            // Allocate then read the array of minimally matching EGL configs
+            EGLConfig[] configs = new EGLConfig[numConfigs];
+            egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);
+
+            // Now return the "best" one
+            return chooseConfig(egl, display, configs);
+        }
+
+        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+                EGLConfig[] configs)
+        {
+            for(EGLConfig config : configs)
+                {
+                int d = findConfigAttrib(egl, display, config,
+                        EGL10.EGL_DEPTH_SIZE, 0);
+                int s = findConfigAttrib(egl, display, config,
+                        EGL10.EGL_STENCIL_SIZE, 0);
+
+                // We need at least mDepthSize and mStencilSize bits
+                if (d < mDepthSize || s < mStencilSize)
+                    continue;
+
+                // We want an *exact* match for red/green/blue/alpha
+                int r = findConfigAttrib(egl, display, config,
+                        EGL10.EGL_RED_SIZE, 0);
+                int g = findConfigAttrib(egl, display, config,
+                            EGL10.EGL_GREEN_SIZE, 0);
+                int b = findConfigAttrib(egl, display, config,
+                            EGL10.EGL_BLUE_SIZE, 0);
+                int a = findConfigAttrib(egl, display, config,
+                        EGL10.EGL_ALPHA_SIZE, 0);
+
+                if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
+                    return config;
+                }
+            return null;
+        }
+
+        private int findConfigAttrib(EGL10 egl, EGLDisplay display,
+                EGLConfig config, int attribute, int defaultValue)
+        {
+            if (egl.eglGetConfigAttrib(display, config, attribute, mValue))
+                {
+                return mValue[0];
+                }
+            return defaultValue;
+        }
+
+        // Subclasses can adjust these values:
+        protected int mRedSize;
+        protected int mGreenSize;
+        protected int mBlueSize;
+        protected int mAlphaSize;
+        protected int mDepthSize;
+        protected int mStencilSize;
+        private int[] mValue = new int[1];
+    }
+
+    private static class Renderer implements GLSurfaceView.Renderer
+    {
+        private long vtkContext;
+
+        public void onDrawFrame(GL10 gl)
+        {
+            JavaVTKLib.render(vtkContext);
+        }
+
+        // forward events to VTK for it to handle
+        public void onKeyEvent(boolean down, KeyEvent ke)
+        {
+            JavaVTKLib.onKeyEvent(vtkContext, down, ke.getKeyCode(),
+                ke.getMetaState(),
+                ke.getRepeatCount());
+        }
+
+        // forward events to VTK for it to handle
+        public void onMotionEvent(final MotionEvent me)
+        {
+            try {
+                int numPtrs = me.getPointerCount();
+                float [] xPos = new float[numPtrs];
+                float [] yPos = new float[numPtrs];
+                int [] ids = new int[numPtrs];
+                for (int i = 0; i < numPtrs; ++i)
+                    {
+                        ids[i] = me.getPointerId(i);
+                        xPos[i] = me.getX(i);
+                        yPos[i] = me.getY(i);
+                    }
+
+                int actionIndex = me.getActionIndex();
+                int actionMasked = me.getActionMasked();
+                int actionId = me.getPointerId(actionIndex);
+
+                if (actionMasked != 2)
+                {
+                    Log.e(TAG, "Got action " + actionMasked + " on index " + actionIndex + " has id " + actionId);
+                }
+                JavaVTKLib.onMotionEvent(vtkContext,
+                                         actionMasked,
+                                         actionId,
+                                         numPtrs, xPos, yPos, ids,
+                                         me.getMetaState());
+            } catch (IllegalArgumentException e) {
+                Log.e(TAG, "Bogus motion event");
+            }
+        }
+
+        public void onSurfaceChanged(GL10 gl, int width, int height)
+        {
+            vtkContext = JavaVTKLib.init(width, height);
+        }
+
+        public void onSurfaceCreated(GL10 gl, EGLConfig config)
+        {
+            // Do nothing.
+        }
+    }
+
+    // forward events to rendering thread for it to handle
+    public boolean onKeyUp(int keyCode, KeyEvent event)
+    {
+        final KeyEvent keyEvent = event;
+        queueEvent(new Runnable()
+            {
+            public void run()
+                {
+                myRenderer.onKeyEvent(false, keyEvent);
+                }
+            });
+        return true;
+    }
+
+    // forward events to rendering thread for it to handle
+    public boolean onKeyDown(int keyCode, KeyEvent event)
+    {
+        final KeyEvent keyEvent = event;
+        queueEvent(new Runnable()
+            {
+            public void run()
+                {
+                myRenderer.onKeyEvent(true, keyEvent);
+                }
+            });
+        return true;
+    }
+
+    // forward events to rendering thread for it to handle
+    public boolean onTouchEvent(MotionEvent event)
+    {
+        final MotionEvent motionEvent = event;
+        queueEvent(new Runnable()
+            {
+            public void run()
+                {
+                myRenderer.onMotionEvent(motionEvent);
+                }
+            });
+        return true;
+    }
+}