diff options
Diffstat (limited to 'platform')
20 files changed, 1626 insertions, 270 deletions
diff --git a/platform/android/example/.gitignore b/platform/android/example/.gitignore new file mode 100644 index 00000000..c474948d --- /dev/null +++ b/platform/android/example/.gitignore @@ -0,0 +1,10 @@ +*.iml +.gradle +/local.properties +/.idea/* +.DS_Store +/build +/captures +/gradle +/gradlew +/gradlew.bat diff --git a/platform/android/example/README b/platform/android/example/README deleted file mode 100644 index 9a2acc77..00000000 --- a/platform/android/example/README +++ /dev/null @@ -1,12 +0,0 @@ -This is a very basic example viewer using the new JNI classes. - -The build system is a bit incomplete. - -You need gradle 2.10 (exactly!). - -Copy the libmupdf_java.so file from the original viewer build: - $ cd ../viewer && ndk-build - $ cp ../viewer/libs/armeabi-v7a/libmupdf_java.so mupdf/libs/armeabi-v7a/libmupdf_java.so - -Build and install on device: - $ gradle-2.10 installArmDebug diff --git a/platform/android/example/app/.gitignore b/platform/android/example/app/.gitignore new file mode 100644 index 00000000..796b96d1 --- /dev/null +++ b/platform/android/example/app/.gitignore @@ -0,0 +1 @@ +/build diff --git a/platform/android/example/app/build.gradle b/platform/android/example/app/build.gradle index 5d433deb..3a1b25b3 100644 --- a/platform/android/example/app/build.gradle +++ b/platform/android/example/app/build.gradle @@ -1,46 +1,26 @@ -apply plugin: 'com.android.model.application' - -model { - - android { - compileSdkVersion = 23 - buildToolsVersion = "23.0.2" - - defaultConfig.with { - applicationId = "com.artifex.mupdf.example" - minSdkVersion.apiLevel = 8 - targetSdkVersion.apiLevel = 16 - versionCode = 1 - versionName = "1.0" - } - } - - android.buildTypes { - release { - minifyEnabled = false - proguardFiles.add(file('proguard-rules.pro')) - } - } - - android.productFlavors { - create("arm") { - ndk.with { - // You can customize the NDK configurations for each - // productFlavors and buildTypes. - abiFilters.add("armeabi") - } - - } - } - - /* This is important, it will run lint checks but won't abort build */ - android.lintOptions { - abortOnError false - } - +apply plugin: 'com.android.application' + +android { + compileSdkVersion 23 + buildToolsVersion "23.0.2" + + defaultConfig { + applicationId "com.artifex.mupdf.example" + minSdkVersion 16 + targetSdkVersion 16 + versionCode 1 + versionName "1.0" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } } dependencies { - compile fileTree(dir: 'libs', include: ['*.jar','*.so']) - compile project(':mupdf') + compile fileTree(dir: 'libs', include: ['*.jar']) + compile 'com.android.support:appcompat-v7:23.4.0' + compile project(':mupdf') } diff --git a/platform/android/example/app/src/main/AndroidManifest.xml b/platform/android/example/app/src/main/AndroidManifest.xml index c1dc4e52..bdd8e804 100644 --- a/platform/android/example/app/src/main/AndroidManifest.xml +++ b/platform/android/example/app/src/main/AndroidManifest.xml @@ -3,7 +3,7 @@ package="com.artifex.mupdf.example"> <uses-sdk - android:minSdkVersion="8" + android:minSdkVersion="16" android:targetSdkVersion="16" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> diff --git a/platform/android/example/app/src/main/java/com/artifex/mupdf/example/DocViewActivity.java b/platform/android/example/app/src/main/java/com/artifex/mupdf/example/DocViewActivity.java index a0e989ff..32f2cecd 100644 --- a/platform/android/example/app/src/main/java/com/artifex/mupdf/example/DocViewActivity.java +++ b/platform/android/example/app/src/main/java/com/artifex/mupdf/example/DocViewActivity.java @@ -1,105 +1,30 @@ package com.artifex.mupdf.example; import android.app.Activity; -import android.graphics.Bitmap; import android.net.Uri; import android.os.Bundle; -import android.view.View; -import android.widget.ImageView; -import android.widget.TextView; -import com.artifex.mupdf.fitz.ColorSpace; -import com.artifex.mupdf.fitz.Document; -import com.artifex.mupdf.fitz.Matrix; -import com.artifex.mupdf.fitz.Page; -import com.artifex.mupdf.fitz.Pixmap; +import com.artifex.mupdf.android.DocView; public class DocViewActivity extends Activity { - private int mPageCount; - private int mCurrentPage; - - Document mDocument; - Page mPage; - Bitmap mBitmap = null; - - ImageView mImageView; - TextView mTextView; + private DocView mDocView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - setContentView(R.layout.activity_doc_view); - mImageView = (ImageView)findViewById(R.id.image_view); - mTextView = (TextView)findViewById(R.id.page_text); + // set up UI + setContentView(R.layout.activity_doc_view); + mDocView = (DocView)findViewById(R.id.doc_view); - // load the doc + // get the file path Uri uri = getIntent().getData(); - String path = Uri.decode(uri.getEncodedPath()); - mDocument = new Document(path); - mPageCount = mDocument.countPages(); - - // show the first page - mCurrentPage = 0; - displayCurrentPage(); - } + final String path = Uri.decode(uri.getEncodedPath()); - public void onFirstPageButton(final View v) - { - mCurrentPage = 0; - displayCurrentPage(); - } - - public void onPreviousPageButton(final View v) - { - if (mCurrentPage > 0) - { - mCurrentPage--; - displayCurrentPage(); - } + // start the view + mDocView.start(path); } - public void onNextPageButton(final View v) - { - if (mCurrentPage < mPageCount-1) - { - mCurrentPage++; - displayCurrentPage(); - } - } - - public void onLastPageButton(final View v) - { - mCurrentPage = mPageCount-1; - displayCurrentPage(); - } - - private void displayCurrentPage() - { - // report the page number - mTextView.setText(String.format("page %d of %d",mCurrentPage+1,mPageCount)); - - // get the page - mPage = mDocument.loadPage(mCurrentPage); - - // create a matrix that renders at 300 DPI - Matrix m = new Matrix(); - m.scale(300.0f/72.0f); - - // create a new bitmap for the page - Bitmap old = mBitmap; - Pixmap pixmap = mPage.toPixmap(m, ColorSpace.DeviceBGR); - mBitmap = Bitmap.createBitmap(pixmap.getWidth(), pixmap.getHeight(), Bitmap.Config.ARGB_8888); - int [] pixels = pixmap.getPixels(); - mBitmap.setPixels(pixels, 0, pixmap.getWidth(), 0, 0, pixmap.getWidth(), pixmap.getHeight()); - - // set the bitmap in the UI - mImageView.setImageBitmap(mBitmap); - - // recycle the old bitmap - if (old!=null) - old.recycle(); - } } diff --git a/platform/android/example/app/src/main/res/layout/activity_doc_view.xml b/platform/android/example/app/src/main/res/layout/activity_doc_view.xml index 05cee21a..7f5ece24 100644 --- a/platform/android/example/app/src/main/res/layout/activity_doc_view.xml +++ b/platform/android/example/app/src/main/res/layout/activity_doc_view.xml @@ -4,64 +4,10 @@ android:layout_height="match_parent" android:orientation="vertical"> - <LinearLayout - android:orientation="horizontal" - android:layout_width="match_parent" - android:layout_height="wrap_content"> - - <Button - android:layout_width="wrap_content" - android:layout_height="wrap_content" - android:text="|<-" - android:id="@+id/first_page_button" - android:onClick="onFirstPageButton" - android:minWidth="60dp" /> - - <Button - android:layout_width="wrap_content" - android:layout_height="wrap_content" - android:text="<" - android:id="@+id/previous_page_button" - android:onClick="onPreviousPageButton" - android:minWidth="60dp" /> - - <Button - android:layout_width="wrap_content" - android:layout_height="wrap_content" - android:text=">" - android:id="@+id/next_page_button" - android:onClick="onNextPageButton" - android:minWidth="60dp" /> - - <Button - android:layout_width="wrap_content" - android:layout_height="wrap_content" - android:text="->|" - android:id="@+id/last_page_button" - android:onClick="onLastPageButton" - android:minWidth="60dp" /> - - <TextView - android:layout_width="wrap_content" - android:layout_height="wrap_content" - android:textAppearance="?android:attr/textAppearanceMedium" - android:text="Medium Text" - android:textColor="@color/white" - android:id="@+id/page_text" /> - - </LinearLayout> - - <LinearLayout - android:orientation="vertical" + <com.artifex.mupdf.android.DocView + android:id="@+id/doc_view" android:layout_width="match_parent" android:layout_height="match_parent"> - - <ImageView - android:id="@+id/image_view" - android:layout_width="match_parent" - android:layout_height="match_parent"> - </ImageView> - - </LinearLayout> + </com.artifex.mupdf.android.DocView> </LinearLayout> diff --git a/platform/android/example/build.gradle b/platform/android/example/build.gradle index d92ef895..ec337e49 100644 --- a/platform/android/example/build.gradle +++ b/platform/android/example/build.gradle @@ -1,18 +1,23 @@ // Top-level build file where you can add configuration options common to all sub-projects/modules. buildscript { - repositories { - jcenter() - } - dependencies { - classpath 'com.android.tools.build:gradle-experimental:0.6.0-alpha9' - // NOTE: Do not place your application dependencies here; they belong - // in the individual module build.gradle files - } + repositories { + jcenter() + } + dependencies { + classpath 'com.android.tools.build:gradle:2.1.2' + + // NOTE: Do not place your application dependencies here; they belong + // in the individual module build.gradle files + } } allprojects { - repositories { - jcenter() - } + repositories { + jcenter() + } +} + +task clean(type: Delete) { + delete rootProject.buildDir } diff --git a/platform/android/example/local.properties.sample b/platform/android/example/local.properties.sample deleted file mode 100644 index bc40e6ef..00000000 --- a/platform/android/example/local.properties.sample +++ /dev/null @@ -1,5 +0,0 @@ -# Uncomment and edit the appropriate line below. -# Resave this file as local.properties. - -sdk.dir=/path/to/android/sdk -ndk.dir=/path/to/android/ndk diff --git a/platform/android/example/mupdf/.gitignore b/platform/android/example/mupdf/.gitignore new file mode 100644 index 00000000..796b96d1 --- /dev/null +++ b/platform/android/example/mupdf/.gitignore @@ -0,0 +1 @@ +/build diff --git a/platform/android/example/mupdf/build.gradle b/platform/android/example/mupdf/build.gradle index 0add44db..44a5a895 100644 --- a/platform/android/example/mupdf/build.gradle +++ b/platform/android/example/mupdf/build.gradle @@ -1,52 +1,38 @@ -apply plugin: 'com.android.model.library' - -model { - - android { - compileSdkVersion = 23 - buildToolsVersion = "23.0.2" - } - - android.buildTypes { - release { - minifyEnabled = false - proguardFiles.add(file('proguard-rules.pro')) - } - } - - android.sources { - main { - java { - source { - srcDir '../../../java' - exclude 'example' - } - } - jniLibs { - dependencies { - library "libmupdf_java" - } - } - } - } - - repositories { - prebuilt(PrebuiltLibraries) { - libmupdf_java { - binaries.withType(SharedLibraryBinary) { - sharedLibraryFile = file("libs/armeabi-v7a/libmupdf_java.so") - } - } - } - } - - /* This is important, it will run lint checks but won't abort build */ - android.lintOptions { - abortOnError false - } +apply plugin: 'com.android.library' + +android { + compileSdkVersion 23 + buildToolsVersion "23.0.2" + + defaultConfig { + minSdkVersion 16 + targetSdkVersion 16 + versionCode 1 + versionName "1.0" + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + + sourceSets { + main { + java { + // we're getting java sources from two places + srcDirs = ["src/main/java", "../../../java/com"] + exclude "example/*" + } + jni.srcDirs = [] // This prevents the auto generation of Android.mk + jniLibs.srcDir 'libs' // where to find the .so file(s) + } + } } dependencies { - compile fileTree(dir: 'libs', include: ['*.jar','*.so']) + compile fileTree(dir: 'libs', include: ['*.jar']) + compile 'com.android.support:appcompat-v7:23.4.0' } diff --git a/platform/android/example/mupdf/src/main/AndroidManifest.xml b/platform/android/example/mupdf/src/main/AndroidManifest.xml index ee014902..af5dbc58 100644 --- a/platform/android/example/mupdf/src/main/AndroidManifest.xml +++ b/platform/android/example/mupdf/src/main/AndroidManifest.xml @@ -1,12 +1,16 @@ -<manifest xmlns:android="http://schemas.android.com/apk/res/android" +<manifest package="com.artifex.mupdf.mupdf" + xmlns:android="http://schemas.android.com/apk/res/android"> + package="com.artifex.mupdf.fitz"> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.INTERNET" /> - <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="16"/> - <application - android:allowBackup="true" - android:label="@string/app_name" - android:supportsRtl="true"> - </application> + + <application android:allowBackup="true" + android:label="@string/app_name" + android:supportsRtl="true" + > + + </application> + </manifest> diff --git a/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/DocPageView.java b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/DocPageView.java new file mode 100644 index 00000000..5ab52646 --- /dev/null +++ b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/DocPageView.java @@ -0,0 +1,462 @@ +package com.artifex.mupdf.android; + +import android.content.Context; +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; +import android.graphics.Point; +import android.graphics.Rect; +import android.os.AsyncTask; +import android.util.Log; +import android.view.KeyEvent.Callback; +import android.view.View; +import android.view.ViewGroup; + +import com.artifex.mupdf.fitz.AndroidDrawDevice; +import com.artifex.mupdf.fitz.Cookie; +import com.artifex.mupdf.fitz.DisplayList; +import com.artifex.mupdf.fitz.DisplayListDevice; +import com.artifex.mupdf.fitz.Document; +import com.artifex.mupdf.fitz.Matrix; +import com.artifex.mupdf.fitz.Page; + +public class DocPageView extends View implements Callback +{ + private final Document mDoc; + private int mPageNum = -1; + private Page mPage; + private boolean mFinished = false; + + private float mScale = 1.0f; + private float mZoom = 1.0f; + + // drawing bitmap + private Bitmap mDrawBitmap = null; + private Rect mDrawSrcRect = new Rect(); + private final Rect mDrawDstRect = new Rect(); + private final Rect sourceRect = new Rect(); + private final Rect renderRect = new Rect(); + private float renderScale; + + // current size of this view + private Point mSize; + + // for drawing + private final Paint mPainter; + private final Rect mSrcRect = new Rect(); + private final Rect mDstRect = new Rect(); + private float drawScale; + + private static final boolean DEBUG_PAGE_RENDERING = false; + + private static final float mResolution = 160f; + + DisplayList pageContents = null; + DisplayList annotContents = null; + + public DocPageView(Context context, Document theDoc) + { + super(context); + setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)); + + mDoc = theDoc; + mPainter = new Paint(); + + setFocusable(true); + setFocusableInTouchMode(true); + } + + public void setupPage(final int thePageNum, int w, int h) + { + // if the page number has not yet been set, or has changed, + // make a new page object. + if (thePageNum != mPageNum) + { + mPageNum = thePageNum; + + // de-cache contents and annotations + if (pageContents != null) { + pageContents.destroy(); + pageContents = null; + } + if (annotContents != null) { + annotContents.destroy(); + annotContents = null; + } + + // destroy the page before making a new one. + if (mPage!=null) + mPage.destroy(); + mPage = mDoc.loadPage(mPageNum); + } + + // calculate zoom that makes page fit + + com.artifex.mupdf.fitz.Rect pageBounds = mPage.getBounds(); + + float pagew = (pageBounds.x1 - pageBounds.x0)*mResolution/72f; + float pageH = (pageBounds.y1 - pageBounds.y0)*mResolution/72f; + + mZoom = w/pagew; + mSize = new Point((int)(pagew*mZoom), (int)(pageH*mZoom)); + } + + public void setNewScale(float scale) { + mScale = scale; + } + + public int getCalculatedWidth() + { + return (int)(mSize.x * mScale); + } + + public int getCalculatedHeight() + { + return (int)(mSize.y * mScale); + } + + // a test for real visibility + private static final Rect visRect = new Rect(); + public boolean isReallyVisible() { + return getLocalVisibleRect(visRect); + } + + // This function renders colored rectangles and text in place of the page. + // Use it to test layouts. + private void renderNoPage(Bitmap bitmap, final RenderListener listener, Rect localVisRect, Rect globalVisRect) + { + // specify where to draw to and from + mDrawBitmap = bitmap; + mDrawSrcRect.set(globalVisRect); + mDrawDstRect.set(localVisRect); + + // make a rect representing the entire page in screen coordinates + int[] locations = new int[2]; + getLocationOnScreen(locations); + Rect pageRect = new Rect(locations[0], locations[1], locations[0]+getWidth(), locations[1]+getHeight()); + + // draw a yellow page with a red border containing the page number + + Paint p = new Paint(); + Canvas c = new Canvas(bitmap); + p.setColor(Color.RED); + p.setStyle(Paint.Style.FILL); + c.drawRect(pageRect,p); + + Rect smaller = new Rect(pageRect); + int inset = (int)(40*mScale); + smaller.inset(inset, inset); + p.setColor(Color.YELLOW); + p.setStyle(Paint.Style.FILL); + c.drawRect(smaller,p); + + String s = "" + (mPageNum+1); + p.setColor(Color.BLACK); + p.setTextSize(200.0f*mScale); + c.drawText(s, pageRect.left+(90*mScale), pageRect.top+(290*mScale), p); + + invalidate(); + listener.progress(0); + } + + public void render(Bitmap bitmap, final RenderListener listener) + { + if (mFinished) + return; + + // get local visible rect + Rect localVisRect = new Rect(); + if (!getLocalVisibleRect(localVisRect)) { + listener.progress(0); + return; // not visible + } + + // get global visible rect + Rect globalVisRect = new Rect(); + if (!getGlobalVisibleRect(globalVisRect)) { + listener.progress(0); + return; // not visible + } + + // do the render. + if (DEBUG_PAGE_RENDERING) + renderNoPage(bitmap, listener, localVisRect, globalVisRect); + else + renderPage(bitmap, listener, localVisRect, globalVisRect); + } + + // This function renders the document's page. + private void renderPage(final Bitmap bitmap, final RenderListener listener, final Rect localVisRect, final Rect globalVisRect) + { + // make a rect representing the entire page + // This might be outside the bounds of the bitmap + int[] locations = new int[2]; + getLocationOnScreen(locations); + Rect pageRect = new Rect(locations[0], locations[1], locations[0]+getCalculatedWidth(), locations[1]+getCalculatedHeight()); + + // make a rect representing the patch + // clip this to the bitmap + Rect patchRect = new Rect(pageRect); + patchRect.left = Math.max(patchRect.left,0); + patchRect.top = Math.max(patchRect.top,0); + patchRect.right = Math.min(patchRect.right,bitmap.getWidth()); + patchRect.bottom = Math.min(patchRect.bottom,bitmap.getHeight()); + + // set up the page and patch coordinates for the device + int pageX0 = pageRect.left; + int pageY0 = pageRect.top; + int pageX1 = pageRect.right; + int pageY1 = pageRect.bottom; + + int patchX0 = patchRect.left; + int patchY0 = patchRect.top; + int patchX1 = patchRect.right; + int patchY1 = patchRect.bottom; + + // set up a matrix for scaling + Matrix ctm = Matrix.Identity(); + ctm.scale(mScale*mZoom*mResolution/72f); + + // cache this page's display and annotation lists + cachePage(); + + sourceRect.set(globalVisRect); + renderRect.set(localVisRect); + renderScale = mScale; + + // Render the page in the background + DrawTaskParams params = new DrawTaskParams(new RenderListener() { + @Override + public void progress(int error) + { + // specify where to draw to and from + mDrawBitmap = bitmap; + mDrawSrcRect.set(sourceRect); + mDrawDstRect.set(renderRect); + drawScale = renderScale; + + invalidate(); + listener.progress(0); + } + }, ctm, bitmap, pageX0, pageY0, pageX1, pageY1, patchX0, patchY0, patchX1, patchY1); + + new DrawTask().execute(params, null, null); + } + + private void cachePage() + { + Cookie cookie = new Cookie(); + + if (pageContents==null) + { + // run the display list + pageContents = new DisplayList(); + DisplayListDevice dispDev = new DisplayListDevice(pageContents); + try { + mPage.run(dispDev, new Matrix(1, 0, 0, 1, 0, 0), cookie); + } + catch (RuntimeException e) { + pageContents.destroy(); + dispDev.destroy(); + throw(e); + } + finally { + dispDev.destroy(); + } + } + + if (annotContents==null) + { + // run the annotation list + annotContents = new DisplayList(); + DisplayListDevice annotDev = new DisplayListDevice(annotContents); + try { + mPage.run(annotDev, new Matrix(1, 0, 0, 1, 0, 0), cookie); + } + catch (RuntimeException e) { + annotContents.destroy(); + annotDev.destroy(); + throw(e); + } + finally { + annotDev.destroy(); + } + } + } + + @Override + public void onDraw(Canvas canvas) { + + if (mFinished) + return; + + // get bitmap to draw + Bitmap bitmap = mDrawBitmap; + if (bitmap==null) + return; // not yet rendered + + // set rectangles for drawing + mSrcRect.set(mDrawSrcRect); + mDstRect.set(mDrawDstRect); + + // if the scale has changed, adjust the destination + if (drawScale != mScale) + { + mDstRect.left *= (mScale/drawScale); + mDstRect.top *= (mScale/drawScale); + mDstRect.right *= (mScale/drawScale); + mDstRect.bottom *= (mScale/drawScale); + } + + // draw + canvas.drawBitmap(bitmap, mSrcRect, mDstRect, mPainter); + } + + public boolean onSingleTap(int x, int y) { + // NOTE: when double-tapping, a single-tap will also happen first. + // so that must be safe to do. + return false; + } + + public void onDoubleTap(int x, int y) { + } + + private Point screenToPage(Point p) + { + return screenToPage(p.x, p.y); + } + + private Point screenToPage(int screenX, int screenY) + { + // convert to view-relative + int viewX = screenX; + int viewY = screenY; + int loc[] = new int[2]; + getLocationOnScreen(loc); + viewX -= loc[0]; + viewY -= loc[1]; + + // convert to page-relative + double factor = mZoom * mScale; + int pageX = (int)(((double)viewX)/factor); + int pageY = (int)(((double)viewY)/factor); + + return new Point(pageX,pageY); + } + + public Point pageToView(int pageX, int pageY) + { + double factor = mZoom * mScale; + + int viewX = (int)(((double)pageX)*factor); + int viewY = (int)(((double)pageY)*factor); + + return new Point(viewX, viewY); + } + + public Point viewToPage(int viewX, int viewY) + { + double factor = mZoom * mScale; + + int pageX = (int)(((double)viewX)/factor); + int pageY = (int)(((double)viewY)/factor); + + return new Point(pageX, pageY); + } + + public void finish() + { + mFinished = true; + + // destroy the page + if (mPage!=null) { + mPage.destroy(); + mPage = null; + } + } + + // during layout, a DocView-relative rect is calculated and stashed here. + private final Rect mChildRect = new Rect(); + public void setChildRect(Rect r) {mChildRect.set(r);} + public Rect getChildRect() {return mChildRect;} + + private class DrawTaskParams { + DrawTaskParams (RenderListener listener, Matrix ctm, Bitmap bitmap, + int pageX0, int pageY0, int pageX1, int pageY1, + int patchX0, int patchY0, int patchX1, int patchY1) + { + this.listener = listener; + this.ctm = ctm; + this.bitmap = bitmap; + this.pageX0 = pageX0; + this.pageY0 = pageY0; + this.pageX1 = pageX1; + this.pageY1 = pageY1; + this.patchX0 = patchX0; + this.patchY0 = patchY0; + this.patchX1 = patchX1; + this.patchY1 = patchY1; + } + + public RenderListener listener; + public Matrix ctm; + public Bitmap bitmap; + public int pageX0; + public int pageY0; + public int pageX1; + public int pageY1; + public int patchX0; + public int patchY0; + public int patchX1; + public int patchY1; + } + + // The definition of our task class + private class DrawTask extends AsyncTask<DrawTaskParams, Void, Void> + { + private DrawTaskParams params = null; + + @Override + protected void onPreExecute() { + super.onPreExecute(); + } + + @Override + protected Void doInBackground(DrawTaskParams... paramList) { + params = paramList[0]; + + Cookie cookie = new Cookie(); + AndroidDrawDevice dev = new AndroidDrawDevice(params.bitmap, params.pageX0, params.pageY0, params.pageX1, params.pageY1, params.patchX0, params.patchY0, params.patchX1, params.patchY1); + try { + if (pageContents != null) { + pageContents.run(dev, params.ctm, cookie); + } + if (annotContents != null) { + annotContents.run(dev, params.ctm, cookie); + } + } + catch (Exception e) + { + Log.e("mupdf", e.getMessage()); + } + finally { + dev.destroy(); + } + + return null; + } + + @Override + protected void onProgressUpdate(Void... values) { + super.onProgressUpdate(values); + } + + @Override + protected void onPostExecute(Void result) { + super.onPostExecute(result); + params.listener.progress(0); + } + } + +} diff --git a/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/DocView.java b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/DocView.java new file mode 100644 index 00000000..34613dc3 --- /dev/null +++ b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/DocView.java @@ -0,0 +1,918 @@ +package com.artifex.mupdf.android; + +import android.content.Context; +import android.graphics.Bitmap; +import android.graphics.Point; +import android.graphics.Rect; +import android.graphics.RectF; +import android.os.Handler; +import android.util.AttributeSet; +import android.util.DisplayMetrics; +import android.util.SparseArray; +import android.view.GestureDetector; +import android.view.MotionEvent; +import android.view.ScaleGestureDetector; +import android.view.View; +import android.view.ViewTreeObserver; +import android.view.WindowManager; +import android.widget.Adapter; +import android.widget.AdapterView; +import android.widget.Scroller; + +import com.artifex.mupdf.fitz.Document; + +public class DocView + extends AdapterView<Adapter> + implements GestureDetector.OnGestureListener, ScaleGestureDetector.OnScaleGestureListener, Runnable +{ + private static final int GAP = 20; + + private static final float MIN_SCALE = .15f; + private static final float MAX_SCALE = 5.0f; + + private PageAdapter mAdapter; + private boolean mFinished = false; + + private final SparseArray<View> mChildViews = new SparseArray<View>(3); + + private boolean mScaling; // Whether the user is currently pinch zooming + private float mScale = 1.0f; + private int mXScroll; // Scroll amounts recorded from events. + private int mYScroll; // and then accounted for in onLayout + + private GestureDetector mGestureDetector; + private ScaleGestureDetector mScaleGestureDetector; + + // bitmaps for rendering + // these are created by the activity and set using setBitmaps() + private final static double OVERSIZE_FACTOR = 1.1; + private final Bitmap[] bitmaps = {null,null}; + + private int bitmapIndex = 0; + private boolean renderRequested = false; + private int renderCount = 0; + + // used during layout + private final Rect mChildRect = new Rect(); + private final Rect mViewport = new Rect(); + private final Point mViewportOrigin = new Point(); + private final Rect mBlockRect = new Rect(); + private final Rect mLastBlockRect = new Rect(); + private int mLastLayoutColumns = 1; + protected int mPageCollectionHeight; + private int mPageCollectionWidth; + + // for flinging + private static final int MOVING_DIAGONALLY = 0; + private static final int MOVING_LEFT = 1; + private static final int MOVING_RIGHT = 2; + private static final int MOVING_UP = 3; + private static final int MOVING_DOWN = 4; + + private static final float MIN_FLING_VELOCITY = 1500.0f; + private static final long FLING_THROTTLE_TIME = 20; + + private Scroller mScroller; + private Stepper mStepper; + private int mScrollerLastX; + private int mScrollerLastY; + private long mFlingStartTime; + + // for single- and double-tapping + private long mLastTapTime = 0; + private float lastTapX; + private float lastTapY; + private int mTapStatus = 0; + + private static final int DOUBLE_TAP_TIME = 300; + private static final int SHOW_KEYBOARD_TIME = 500; + + // the document. + private Document mDoc; + + private boolean mStarted = false; + + public DocView(Context context) { + super(context); + initialize(context); + } + + public DocView(Context context, AttributeSet attrs) { + super(context, attrs); + initialize(context); + } + + public DocView(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + initialize(context); + } + + protected Context mContext = null; + + protected void initialize(Context context) + { + mContext = context; + mGestureDetector = new GestureDetector(context, this); + mScaleGestureDetector = new ScaleGestureDetector(context, this); + mScroller = new Scroller(context); + mStepper = new Stepper(this, this); + + // create bitmaps + makeBitmaps(); + } + + private void makeBitmaps() + { + // get current screen size + WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE); + DisplayMetrics metrics = new DisplayMetrics(); + wm.getDefaultDisplay().getMetrics(metrics); + int screenW = metrics.widthPixels; + int screenH = metrics.heightPixels; + + // make two bitmaps. + // make them large enough for both screen orientations, so we don't have to + // change them when the orientation changes. + + int w = (int)(screenW*OVERSIZE_FACTOR); + int h = (int)(screenH*OVERSIZE_FACTOR); + int size = Math.max(w,h); + for (int i=0;i<bitmaps.length;i++) + bitmaps[i] = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888); + } + + public void start(final String path) + { + // wait for the layout to finish + ViewTreeObserver observer = getViewTreeObserver(); + observer.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() + { + @Override + public void onGlobalLayout() + { + getViewTreeObserver().removeOnGlobalLayoutListener(this); + + mAdapter = new PageAdapter(mContext); + mAdapter.setWidth(getWidth()); + mDoc = new Document(path); + mAdapter.setDocument(mDoc); + mScale = 1.0f; + mStarted = true; + triggerRender(); + } + }); + } + + private void onScaleChild(View v, Float scale) + { + ((DocPageView)v).setNewScale(scale); + } + + public void onOrientationChange() + { + triggerRender(); + } + + private void onSizeChange(float factor) + { + mScale *= factor; + scaleChildren(); + requestLayout(); + } + + public boolean onDown(MotionEvent arg0) { + mScroller.forceFinished(true); + return true; + } + + public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { + + // not while we're scaling + if (mScaling) + return true; + + // not while a previous fling is underway + if (!mScroller.isFinished()) + return true; + + // must be really flinging + float vel = Math.max(Math.abs(velocityX),Math.abs(velocityY)); + if (vel<MIN_FLING_VELOCITY) + return false; + + // what direction? + int direction = directionOfTravel(velocityX,velocityY); + + mFlingStartTime = System.currentTimeMillis(); + + switch (direction) + { + case MOVING_DOWN: + smoothScrollBy(0, getHeight()/2); + break; + + case MOVING_UP: + smoothScrollBy(0, -getHeight()/2); + break; + + default: + break; + } + + return true; + } + + private static int directionOfTravel(float vx, float vy) { + if (Math.abs(vx) > 2 * Math.abs(vy)) + return (vx > 0) ? MOVING_RIGHT : MOVING_LEFT; + else if (Math.abs(vy) > 2 * Math.abs(vx)) + return (vy > 0) ? MOVING_DOWN : MOVING_UP; + else + return MOVING_DIAGONALLY; + } + + public void onLongPress(MotionEvent e) { + } + + public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { + + // not if we're scaling + if (mScaling) + return true; + + // not if a previous fling is underway + if (!mScroller.isFinished()) + return true; + + // accumulate scrolling amount. + mXScroll -= distanceX; + mYScroll -= distanceY; + + requestLayout(); + + return true; + } + + public void onShowPress(MotionEvent e) { + } + + protected DocPageView findPageViewContainingPoint(int x, int y, boolean includeMargin) + { + for (int i = 0; i < getChildCount(); i++) + { + // get the rect for the page + View child = getChildAt(i); + Rect childRect = new Rect(); + child.getGlobalVisibleRect(childRect); + + // add in the margin + if (includeMargin) + { + childRect.left -= GAP/2; + childRect.right += GAP/2; + childRect.top -= GAP/2; + childRect.bottom += GAP/2; + } + + // see if the rect contains the point + if (childRect.contains(x,y)) + return (DocPageView)child; + } + + return null; + } + + protected Point eventToScreen(float fx, float fy) + { + int x = Math.round(fx); + int y = Math.round(fy); + Rect docRect = new Rect(); + getGlobalVisibleRect(docRect); + x += docRect.left; + y += docRect.top; + + return new Point(x,y); + } + + protected void doSingleTap(float fx, float fy) + { + // find the page view that was tapped. + Point p = eventToScreen(fx,fy); + final DocPageView dpv = findPageViewContainingPoint(p.x, p.y, false); + if (dpv==null) + return; + + // see if the age wants to handle the single tap + boolean handled = dpv.onSingleTap(p.x,p.y); + + // if not, ... + if (!handled) + { + // schedule a task in the near future to check if we're still a single-tap. + final Handler handler = new Handler(); + final Point tappedPoint = p; + handler.postDelayed(new Runnable() + { + @Override + public void run() + { + if (mTapStatus==1) + { + // still single + } + else + { + // double + } + mTapStatus = 0; + } + }, SHOW_KEYBOARD_TIME); + } + } + + protected void doDoubleTap(float fx, float fy) + { + Point p = eventToScreen(fx,fy); + DocPageView v = findPageViewContainingPoint(p.x, p.y, false); + if (v != null) { + v.onDoubleTap(p.x,p.y); + } + } + + public boolean onSingleTapUp(final MotionEvent e) + { + long now = System.currentTimeMillis(); + if (mLastTapTime!=0 && ((now-mLastTapTime)<DOUBLE_TAP_TIME)) + { + mTapStatus = 2; + doDoubleTap(lastTapX,lastTapY); + mLastTapTime = 0; + } + else + { + mLastTapTime = now; + lastTapX = e.getX(); + lastTapY = e.getY(); + doSingleTap(lastTapX, lastTapY); + mTapStatus = 1; + } + + return false; + } + + private void scaleChildren() + { + // scale children + for (int i=0; i<getPageCount(); i++) + { + DocPageView cv = (DocPageView)getOrCreateChild(i); + cv.setNewScale(mScale); + } + } + + public boolean onScale(ScaleGestureDetector detector) + { + // new scale factor + float previousScale = mScale; + mScale = Math.min(Math.max(mScale * detector.getScaleFactor(), MIN_SCALE), MAX_SCALE); + + // did we really scale? + if (mScale == previousScale) + return true; + + // scale children + scaleChildren(); + + // maintain focus while scaling + float currentFocusX = detector.getFocusX(); + float currentFocusY = detector.getFocusY(); + int viewFocusX = (int)currentFocusX + getScrollX(); + int viewFocusY = (int)currentFocusY + getScrollY(); + mXScroll += viewFocusX - viewFocusX * detector.getScaleFactor(); + mYScroll += viewFocusY - viewFocusY * detector.getScaleFactor(); + + requestLayout(); + + return true; + } + + public boolean onScaleBegin(ScaleGestureDetector detector) { + + mScaling = true; + + // Ignore any scroll amounts yet to be accounted for: the + // screen is not showing the effect of them, so they can + // only confuse the user + mXScroll = mYScroll = 0; + + return true; + } + + public void onScaleEnd(ScaleGestureDetector detector) + { + // When a pinch-scale is done, we want to get n-across + // to fit properly. + + // get current viewport + Rect viewport = new Rect(); + getGlobalVisibleRect(viewport); + + // if we're at one column and wider than the viewport, + // leave it alone. + if (mLastLayoutColumns==0 && mPageCollectionWidth>=viewport.width()) + { + mScaling = false; + return; + } + + // ratio of the viewport width to layout width + float ratio = ((float)(viewport.width()))/((float)(mPageCollectionWidth)); + + // set a new scale factor + mScale *= ratio; + scaleChildren(); + + // scroll so the left edged is flush to the viewport. + mXScroll +=getScrollX(); + + requestLayout(); + + mScaling = false; + } + + @Override + public boolean onTouchEvent(MotionEvent event) { + + if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_DOWN) { + // do something when user interaction begins + } + + if ((event.getAction() & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_UP) { + // do something when user interaction ends + triggerRender(); + } + + mScaleGestureDetector.onTouchEvent(event); + mGestureDetector.onTouchEvent(event); + + return true; + } + + protected int getPageCount() + { + return getAdapter().getCount(); + } + + protected void onLayout(boolean changed, int left, int top, int right, int bottom) { + + super.onLayout(changed, left, top, right, bottom); + + if (!mStarted) + return; + + // not if there are no pages + if (getPageCount()==0) + return; + + int numDocPages = getPageCount(); + + // not if we've been finished + if (finished()) + return; + + // perform any pending scrolling + scrollBy(-mXScroll, -mYScroll); + mXScroll = mYScroll = 0; + + // get current viewport + mViewportOrigin.set(getScrollX(), getScrollY()); + getGlobalVisibleRect(mViewport); + mViewport.offsetTo(mViewportOrigin.x, mViewportOrigin.y); + + // find the widest child + int maxw = 0; + for (int i=0; i<getPageCount(); i++) + { + DocPageView cv = (DocPageView)getOrCreateChild(i); + + int childWidth = cv.getCalculatedWidth(); + if (childWidth>maxw) + maxw = childWidth; + } + + // how many columns? + double dcol = (double)(mViewport.width()+GAP)/(double)(maxw+GAP); + int columns = (int) dcol; + + // lay them out + int mostVisibleChildHeight = -1; + int childTop = 0; + mPageCollectionHeight = 0; + mPageCollectionWidth = 0; + int column = 0; + mBlockRect.setEmpty(); + + for (int i=0; i<getPageCount(); i++) + { + DocPageView cv = (DocPageView)getOrCreateChild(i); + int childWidth = cv.getCalculatedWidth(); + int childHeight = cv.getCalculatedHeight(); + int childLeft = column * (maxw + GAP); + int childRight = childLeft + childWidth; + int childBottom = childTop + childHeight; + mChildRect.set(childLeft, childTop, childRight, childBottom); + + // stash the rect in the page view for later use. + cv.setChildRect(mChildRect); + + // at each layout, we remember the entire width and height of the laid-out + // pages. This is used in applying constraints to scrolling amounts. + if (childBottom> mPageCollectionHeight) + mPageCollectionHeight = childBottom; + if (childRight>mPageCollectionWidth) + mPageCollectionWidth = childRight; + + if (mBlockRect.isEmpty()) + mBlockRect.set(mChildRect); + else + mBlockRect.union(mChildRect); + + if (mChildRect.intersect(mViewport) && i<numDocPages) + { + // visible, so include in layout + if (cv.getParent()==null) + addChildToLayout(cv); + cv.layout(childLeft, childTop, childRight, childBottom); + cv.invalidate(); + } + else + { + // not visible, so remove from layout + removeViewInLayout(cv); + } + + column++; + if (column >= columns) { + column = 0; + childTop += childHeight; + childTop += GAP; + } + } + + // if the number of columns has changed, do some scrolling to adjust + if (mScaling && columns>=1 && mLastLayoutColumns>=1 && mLastLayoutColumns!=columns) + { + // x - center in the viewport + int dx = mBlockRect.centerX() - mViewport.centerX(); + scrollBy(dx,0); + + // y - attempt to keep what's in the center of the viewport in view. + int oldy = mViewport.centerY() - mLastBlockRect.top; + int newy = (int)((float)oldy*mBlockRect.height()/mLastBlockRect.height()); + scrollBy(0,newy-oldy); + } + mLastLayoutColumns = columns; + mLastBlockRect.set(mBlockRect); + + // see if we're handling a start page + handleStartPage(); + + triggerRender(); + } + + // start page, get and set. + private int mStartPage = 0; + public void setStartPage(int page) { + mStartPage = page; + } + protected int getStartPage() {return mStartPage;} + + // handle start page + public void handleStartPage() + { + // if we've been given a start page, go there. + final int start = getStartPage(); + if (start>0) + { + setStartPage(0); // but just once + + // post all of this so that we get an additional layout request + final Handler handler = new Handler(); + handler.post(new Runnable() { + @Override + public void run() { + DocPageView cv = (DocPageView)getOrCreateChild(start-1); + Rect r = cv.getChildRect(); + scrollBy(0,r.top); + requestLayout(); + } + }); + } + } + + // override the view's scrollBy() function so we can + // take the opportunity to apply some constraints + + @Override + public void scrollBy(int dx, int dy) + { + Point p = constrainScrollBy(dx, dy); + super.scrollBy(p.x, p.y); + } + + // apply contraints to every scroll request. + + protected Point constrainScrollBy(int dx, int dy) + { + int vph; + int vpw; + { + Rect viewport = new Rect(); + getGlobalVisibleRect(viewport); + vph = viewport.height(); + vpw = viewport.width(); + } + int sx = getScrollX(); + int sy = getScrollY(); + + if (mPageCollectionWidth <= vpw) + { + // not too far to the right + if (mPageCollectionWidth-sx-dx > vpw) + dx = 0; + + // not too far to the left + if (sx+dx>0) + dx = -sx; + } + else + { + // not too far to the right + if (mPageCollectionWidth < sx+vpw+dx) + dx = 0; + + // not too far to the left + if (sx+dx < 0) + dx = -sx; + } + + if (mPageCollectionHeight <= vph) + { + // not too far down + if (mPageCollectionHeight-sy-dy > vph) + dy = 0; + + // not too far up + if (sy+dy>0) + dy = -sy; + } + else + { + // not too far down + if (sy+dy < 0) + dy = -sy; + + // not too far up. + if (mPageCollectionHeight+2*vph/3 < sy+vph+dy) + dy = 0; + } + + return new Point(dx, dy); + } + + @Override + public Adapter getAdapter() { + return mAdapter; + } + + @Override + public View getSelectedView() { + return null; + } + + @Override + public void setAdapter(Adapter adapter) { + mAdapter = (PageAdapter)adapter; + requestLayout(); + } + + @Override + public void setSelection(int arg0) { + throw new UnsupportedOperationException("setSelection is not supported"); + } + + private View getCached() { + return null; + } + + protected View getOrCreateChild(int i) { + View v = mChildViews.get(i); + if (v == null) { + v = getViewFromAdapter(i); + mChildViews.append(i, v); // Record the view against it's adapter index + onScaleChild(v, mScale); + } + + return v; + } + + protected View getViewFromAdapter(int index) + { + return getAdapter().getView(index, getCached(), this); + } + + private void addChildToLayout(View v) { + LayoutParams params = v.getLayoutParams(); + if (params == null) { + params = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT); + } + addViewInLayout(v, 0, params, true); + } + + private void triggerRender() + { + // Note that a render is needed + renderRequested = true; + + // If the previous render has completed, start a new one. Otherwise + // a new one will start as soon as the previous one completes. + if (renderCount == 0) + renderPages(); + } + + private void renderPages() + { + renderRequested = false; + + if (mFinished) + return; + + if (bitmaps == null) + return; + + // Rotate to the next bitmap + bitmapIndex++; + if (bitmapIndex>=bitmaps.length) + bitmapIndex = 0; + + // iterate through the children + for (int i = 0; i < getPageCount(); i++) { + + if (mFinished) + return; + + final DocPageView cv = (DocPageView) getOrCreateChild(i); + if (cv.getParent()!=null && cv.isReallyVisible()) { + // Count up as we kick off rendering of each visible page + renderCount++; + cv.render(bitmaps[bitmapIndex], new RenderListener() { + @Override + public void progress(int error) { + + if (error==0) + cv.invalidate(); + + // Count down as they complete + renderCount--; + + if (renderCount==0) { + if (renderRequested) { + // If this phase of rendering has completed and another has + // been requested, start it now + renderPages(); + } + } + } + }); + } + } + } + + @Override + public void run() + { + if (!mScroller.isFinished()) + { + mScroller.computeScrollOffset(); + int x = mScroller.getCurrX(); + int y = mScroller.getCurrY(); + mXScroll += x - mScrollerLastX; + mYScroll += y - mScrollerLastY; + mScrollerLastX = x; + mScrollerLastY = y; + + // limit the amount of repeated layouts. + long tNow = System.currentTimeMillis(); + long diff = tNow - mFlingStartTime; + if (diff>FLING_THROTTLE_TIME) + { + requestLayout(); + mFlingStartTime = tNow; + } + + mStepper.prod(); + } + else + { + // one more + long tNow = System.currentTimeMillis(); + if (tNow != mFlingStartTime) + requestLayout(); + } + } + + public void finish() + { + // we're done with this view. + mFinished = true; + + // first, hide and remove all the children + for (int i=0; i<getPageCount(); i++) + { + DocPageView cv = (DocPageView)getOrCreateChild(i); + cv.setVisibility(GONE); + removeViewInLayout(cv); + cv.finish(); + } + } + + public boolean finished() {return mFinished;} + + protected void smoothScrollBy(int dx, int dy) + { + mScrollerLastX = mScrollerLastY = 0; + mScroller.startScroll(0, 0, dx, dy, 400); + mStepper.prod(); + } + + public void scrollToPage(int pageNumber) + { + // scroll to bring the page into view + + // get current viewport + Rect viewport = new Rect(); + getGlobalVisibleRect(viewport); + + // offset it based on current scroll position + Point viewportOrigin = new Point(); + viewportOrigin.set(getScrollX(), getScrollY()); + viewport.offsetTo(viewportOrigin.x, viewportOrigin.y); + + // get page rect from last layout + DocPageView cv = (DocPageView)getOrCreateChild(pageNumber); + Rect childRect = cv.getChildRect(); + + // scroll + if ((childRect.height()) > viewport.height()) + { + // put the top of the page at the top and the left at 0 + smoothScrollBy(getScrollX(),getScrollY()-childRect.top); + } + else + { + // if the whole page is not visible, move the center of the page at the center + if (childRect.top < viewport.top || childRect.bottom > viewport.bottom) + { + if (childRect.top==0) + smoothScrollBy(0, getScrollY()); + else + smoothScrollBy(0, getScrollY() + viewport.height() / 2 - (childRect.bottom + childRect.top) / 2); + } + } + } + + private Point viewToScreen(Point p) + { + Point newPoint = new Point(p); + + Rect r = new Rect(); + this.getGlobalVisibleRect(r); + + newPoint.offset(r.left, r.top); + + return newPoint; + } + + public void scrollBoxIntoView (int pageNum, RectF box) + { + // get our viewport + Rect viewport = new Rect(); + getGlobalVisibleRect(viewport); + viewport.offset(0,-viewport.top); + + // get the location of the box's lower left corner, + // relative to the viewport + DocPageView cv = (DocPageView)getOrCreateChild(pageNum); + Point point = cv.pageToView((int)box.left,(int)box.bottom); + Rect childRect = cv.getChildRect(); + point.y += childRect.top; + point.y -= getScrollY(); + + // if the point is outside the viewport, scroll so it is. + if (point.y<viewport.top || point.y>viewport.bottom) + { + int diff = (viewport.top + viewport.bottom)/2 - point.y; + smoothScrollBy(0,diff); + } + } +} diff --git a/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/PageAdapter.java b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/PageAdapter.java new file mode 100644 index 00000000..46a93068 --- /dev/null +++ b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/PageAdapter.java @@ -0,0 +1,61 @@ +package com.artifex.mupdf.android; + +import android.app.Activity; +import android.content.Context; +import android.view.View; +import android.view.ViewGroup; +import android.widget.BaseAdapter; + +import com.artifex.mupdf.fitz.Document; + +public class PageAdapter extends BaseAdapter +{ + private final Context mContext; + private Document mDoc; + + public PageAdapter(Context c) { + mContext = c; + } + + public void setDocument(Document doc) { + mDoc = doc; + } + private int mWidth; + public void setWidth(int w) {mWidth=w;} + + @Override + public int getCount() { + return mDoc.countPages(); + } + + public Object getItem(int position) { + return null; // not used + } + + public long getItemId(int position) { + return 0; // not used + } + + public View getView(final int position, View convertView, ViewGroup parent) + { + // make or reuse a view + DocPageView pageView; + + final Activity activity = (Activity)mContext; + if (convertView == null) + { + // make a new one + pageView = new DocPageView(activity, mDoc); + } + else + { + // reuse an existing one + pageView = (DocPageView) convertView; + } + + // set up the page + pageView.setupPage(position, mWidth, 1); + + return pageView; + } +} diff --git a/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/RenderListener.java b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/RenderListener.java new file mode 100644 index 00000000..7030ef8d --- /dev/null +++ b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/RenderListener.java @@ -0,0 +1,6 @@ +package com.artifex.mupdf.android; + +public interface RenderListener +{ + void progress(int error); +}
\ No newline at end of file diff --git a/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/Stepper.java b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/Stepper.java new file mode 100644 index 00000000..8a6b29a5 --- /dev/null +++ b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/android/Stepper.java @@ -0,0 +1,42 @@ +package com.artifex.mupdf.android; + +import android.annotation.SuppressLint; +import android.os.Build; +import android.view.View; + +public class Stepper { + private final View mPoster; + private final Runnable mTask; + private boolean mPending; + + public Stepper(View v, Runnable r) { + mPoster = v; + mTask = r; + mPending = false; + } + + @SuppressLint("NewApi") + public void prod() { + if (!mPending) { + mPending = true; + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) { + mPoster.postOnAnimation(new Runnable() { + @Override + public void run() { + mPending = false; + mTask.run(); + } + }); + } else { + mPoster.post(new Runnable() { + @Override + public void run() { + mPending = false; + mTask.run(); + } + }); + + } + } + } +} diff --git a/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/fitz/AndroidDrawDevice.java b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/fitz/AndroidDrawDevice.java new file mode 100644 index 00000000..407ddae1 --- /dev/null +++ b/platform/android/example/mupdf/src/main/java/com/artifex/mupdf/fitz/AndroidDrawDevice.java @@ -0,0 +1,25 @@ +package com.artifex.mupdf.fitz; + +import android.graphics.Bitmap; + +import com.artifex.mupdf.fitz.NativeDevice; +import com.artifex.mupdf.fitz.RectI; + +public final class AndroidDrawDevice extends NativeDevice +{ + // NOT static. + private native long newNative(Bitmap bitmap, int pageX0, int pageY0, int pageX1, int pageY1, int patchX0, int patchY0, int patchX1, int patchY1); + + // Construction + public AndroidDrawDevice(Bitmap bitmap, int pageX0, int pageY0, int pageX1, int pageY1, int patchX0, int patchY0, int patchX1, int patchY1) + { + super(0); + pointer = newNative(bitmap, pageX0, pageY0, pageX1, pageY1, patchX0, patchY0, patchX1, patchY1); + } + + public AndroidDrawDevice(Bitmap bitmap, RectI page, RectI patch) + { + super(0); + pointer = newNative(bitmap, page.x0, page.y0, page.x1, page.y1, patch.x0, patch.y0, patch.x1, patch.y1); + } +} diff --git a/platform/android/example/mupdf/src/main/res/values/strings.xml b/platform/android/example/mupdf/src/main/res/values/strings.xml index 0fba1bfb..0f541156 100644 --- a/platform/android/example/mupdf/src/main/res/values/strings.xml +++ b/platform/android/example/mupdf/src/main/res/values/strings.xml @@ -1,3 +1,3 @@ <resources> - <string name="app_name">MuPDF</string> + <string name="app_name">mupdf</string> </resources> diff --git a/platform/java/mupdf_native.c b/platform/java/mupdf_native.c index 7530b041..5cef1e70 100644 --- a/platform/java/mupdf_native.c +++ b/platform/java/mupdf_native.c @@ -1991,13 +1991,14 @@ newNativeAndroidDrawDevice(JNIEnv *env, jobject self, fz_context *ctx, jobject o * match the pixels data */ pixbbox = clip; pixbbox.x1 = pixbbox.x0 + width; + pixmap = fz_new_pixmap_with_bbox_and_data(ctx, fz_device_rgb(ctx), &pixbbox, 1, &dummy); ninfo = fz_malloc(ctx, sizeof(*ninfo)); ninfo->pixmap = pixmap; ninfo->lock = lock; ninfo->unlock = unlock; - ninfo->pageX0 = pageX0; - ninfo->pageY0 = pageY0; + ninfo->pageX0 = patchX0; + ninfo->pageY0 = patchY0; ninfo->width = width; ninfo->object = obj; (*env)->SetLongField(env, self, fid_NativeDevice_nativeInfo, jlong_cast(ninfo)); @@ -2030,7 +2031,7 @@ static void androidDrawDevice_lock(JNIEnv *env, NativeDeviceInfo *info) } /* Now offset pixels to allow for the page offsets */ - //pixels += sizeof(int32_t) * (info->pageX0 + info->width * info->pageY0); + pixels += sizeof(int32_t) * (info->pageX0 + info->width * info->pageY0); info->pixmap->samples = pixels; } |