@reekon-tools/react-native-pdf-canvas 0.1.0 → 0.2.0

package/ios/Sources/PdfCanvasCore/PdfCanvasDocumentPool.m

@@ -1,389 +0,0 @@
-#import "PdfCanvasDocumentPool.h"
-
-#import "PdfCanvasPreflight.h"
-
-const NSInteger kPdfCanvasMaxPoolSize = 4;
-
-/* ------------------------------------------------------------------ *
- * Private surfaces
- * ------------------------------------------------------------------ */
-
-@interface PdfCanvasDocumentLease ()
-/**
- * @param document retained by the lease and released on dealloc, which is what
- *     makes close-while-leased safe — see the pool's header note. The caller
- *     keeps its own reference and must balance its own create.
- */
-- (instancetype)initWithDocument:(CGPDFDocumentRef)document
-                         fileURL:(nullable NSURL *)fileURL
-                            data:(nullable NSData *)data
-                        password:(nullable NSString *)password;
-@end
-
-@interface PdfCanvasDocumentPool ()
-+ (NSInteger)clampSize:(NSInteger)size;
-+ (nullable instancetype)poolWithLeases:
-                             (NSArray<PdfCanvasDocumentLease *> *)leases
-                                  label:(NSString *)label
-                                  error:(NSError *_Nullable *_Nullable)error;
-- (instancetype)initWithLeases:(NSArray<PdfCanvasDocumentLease *> *)leases
-                     pageCount:(NSInteger)pageCount;
-@end
-
-/* ------------------------------------------------------------------ *
- * Opening one document
- * ------------------------------------------------------------------ */
-
-/**
- * Unlocks a CGPDF document, or explains why it could not be.
- *
- * The three-way answer is the point, and CoreGraphics gives it cleanly where
- * Android has to infer it from a `SecurityException`:
- *
- *  - not encrypted, or encrypted with an EMPTY user password (owner-password-only
- *    files, which are common) — `CGPDFDocumentIsUnlocked` is already true and
- *    there is nothing to do. Refusing these because `IsEncrypted` is true would
- *    reject a large share of real documents that every reader opens.
- *  - encrypted, password supplied, `CGPDFDocumentUnlockWithPassword` false →
- *    `password-incorrect`.
- *  - encrypted, no password → `password-required`.
- *
- * Note what this backend can do that Android cannot do at all: `PdfRendererPool`
- * REJECTS a non-nil password with `unsupported`, because
- * `android.graphics.pdf.LoadParams` — the only way to supply one — landed at API
- * 35. Encrypted documents work here.
- */
-static BOOL UnlockCGDocument(
-    CGPDFDocumentRef document,
-    NSString *_Nullable password,
-    NSString *label,
-    NSError *_Nullable *_Nullable error) {
-  if (CGPDFDocumentIsUnlocked(document)) {
-    return YES;
-  }
-  if (password.length > 0) {
-    if (CGPDFDocumentUnlockWithPassword(document, password.UTF8String)) {
-      return YES;
-    }
-    PdfCanvasFail(
-        error, PdfCanvasErrorCodePasswordIncorrect,
-        [NSString stringWithFormat:@"The password for %@ was rejected.", label],
-        nil);
-    return NO;
-  }
-  PdfCanvasFail(
-      error, PdfCanvasErrorCodePasswordRequired,
-      [NSString stringWithFormat:@"%@ is encrypted and needs a password.", label],
-      nil);
-  return NO;
-}
-
-/* ------------------------------------------------------------------ *
- * The lease
- * ------------------------------------------------------------------ */
-
-@implementation PdfCanvasDocumentLease {
-  CGPDFDocumentRef _cgDocument;
-  /** Whichever of the two the pool was opened from; exactly one is non-nil. */
-  NSURL *_fileURL;
-  NSData *_data;
-  NSString *_password;
-  PDFDocument *_pdfKitDocument;
-}
-
-- (instancetype)initWithDocument:(CGPDFDocumentRef)document
-                         fileURL:(nullable NSURL *)fileURL
-                            data:(nullable NSData *)data
-                        password:(nullable NSString *)password {
-  self = [super init];
-  if (self != nil) {
-    _cgDocument = CGPDFDocumentRetain(document);
-    _fileURL = fileURL;
-    _data = data;
-    _password = [password copy];
-  }
-  return self;
-}
-
-- (void)dealloc {
-  if (_cgDocument != NULL) {
-    CGPDFDocumentRelease(_cgDocument);
-    _cgDocument = NULL;
-  }
-}
-
-- (CGPDFDocumentRef)cgDocument {
-  return _cgDocument;
-}
-
-- (nullable PDFDocument *)pdfKitDocumentWithError:
-    (NSError *_Nullable *_Nullable)error {
-  if (_pdfKitDocument != nil) {
-    return _pdfKitDocument;
-  }
-
-  PDFDocument *document = _fileURL != nil
-                              ? [[PDFDocument alloc] initWithURL:_fileURL]
-                              : [[PDFDocument alloc] initWithData:_data];
-  if (document == nil) {
-    // CoreGraphics accepted this file and PDFKit did not, which does happen — the
-    // two have separate parsers. Named as such rather than reported as a generic
-    // failure, because the actionable answer is "ask for this raster without
-    // annotations", and only a caller can decide that.
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeCorrupt,
-        @"PDFKit refused a document CoreGraphics accepted, so annotations "
-        @"cannot be drawn for it. Request the raster with annotations: false to "
-        @"use the CoreGraphics path instead.",
-        nil);
-  }
-  if (document.isLocked) {
-    if (_password.length > 0) {
-      if (![document unlockWithPassword:_password]) {
-        return PdfCanvasFail(
-            error, PdfCanvasErrorCodePasswordIncorrect,
-            @"PDFKit rejected the password, though CoreGraphics accepted it.",
-            nil);
-      }
-    } else {
-      return PdfCanvasFail(
-          error, PdfCanvasErrorCodePasswordRequired,
-          @"PDFKit reports this document as locked and no password was given.",
-          nil);
-    }
-  }
-  _pdfKitDocument = document;
-  return document;
-}
-
-@end
-
-/* ------------------------------------------------------------------ *
- * The pool
- * ------------------------------------------------------------------ */
-
-@implementation PdfCanvasDocumentPool {
-  NSMutableArray<PdfCanvasDocumentLease *> *_free;
-  /** Guards `_free` and `_closed`. Never held across a render or an open. */
-  NSLock *_lock;
-  /** Counts available lanes, so `lease` blocks rather than spins. */
-  dispatch_semaphore_t _available;
-  NSInteger _pageCount;
-  NSInteger _size;
-  BOOL _closed;
-}
-
-+ (NSInteger)clampSize:(NSInteger)size {
-  if (size < 1) return 1;
-  if (size > kPdfCanvasMaxPoolSize) return kPdfCanvasMaxPoolSize;
-  return size;
-}
-
-+ (nullable instancetype)openFileURL:(NSURL *)url
-                            password:(nullable NSString *)password
-                                size:(NSInteger)size
-                               error:(NSError *_Nullable *_Nullable)error {
-  if (![PdfCanvasPreflight checkFileURL:url error:error]) {
-    return nil;
-  }
-  const NSInteger lanes = [self clampSize:size];
-  NSMutableArray<PdfCanvasDocumentLease *> *leases =
-      [NSMutableArray arrayWithCapacity:(NSUInteger)lanes];
-  NSString *label = url.lastPathComponent.length > 0 ? url.lastPathComponent
-                                                     : url.path;
-
-  for (NSInteger i = 0; i < lanes; i++) {
-    CGPDFDocumentRef document =
-        CGPDFDocumentCreateWithURL((__bridge CFURLRef)url);
-    if (document == NULL) {
-      // Preflight already ruled out "missing", "unreadable", "empty" and "no
-      // header", so what is left is structure CoreGraphics could not parse.
-      PdfCanvasFail(
-          error, PdfCanvasErrorCodeCorrupt,
-          [NSString stringWithFormat:
-                        @"CoreGraphics could not parse %@ — it has a %%PDF- "
-                        @"header but no usable cross-reference table or page "
-                        @"tree.",
-                        label],
-          nil);
-      return nil;
-    }
-    const BOOL unlocked = UnlockCGDocument(document, password, label, error);
-    if (!unlocked) {
-      CGPDFDocumentRelease(document);
-      return nil;
-    }
-    [leases addObject:[[PdfCanvasDocumentLease alloc] initWithDocument:document
-                                                              fileURL:url
-                                                                 data:nil
-                                                             password:password]];
-    // The lease retained it; this balances the create above.
-    CGPDFDocumentRelease(document);
-  }
-
-  return [self poolWithLeases:leases label:label error:error];
-}
-
-+ (nullable instancetype)openData:(NSData *)data
-                         password:(nullable NSString *)password
-                             size:(NSInteger)size
-                            error:(NSError *_Nullable *_Nullable)error {
-  if (![PdfCanvasPreflight checkData:data error:error]) {
-    return nil;
-  }
-  const NSInteger lanes = [self clampSize:size];
-  NSMutableArray<PdfCanvasDocumentLease *> *leases =
-      [NSMutableArray arrayWithCapacity:(NSUInteger)lanes];
-
-  for (NSInteger i = 0; i < lanes; i++) {
-    // One provider per lane over the SAME immutable NSData. The provider retains
-    // the data, so the bytes outlive this scope, and nothing writes to them.
-    CGDataProviderRef provider =
-        CGDataProviderCreateWithCFData((__bridge CFDataRef)data);
-    if (provider == NULL) {
-      PdfCanvasFail(error, PdfCanvasErrorCodeOutOfMemory,
-                    @"Could not wrap the document bytes in a CGDataProvider.",
-                    nil);
-      return nil;
-    }
-    CGPDFDocumentRef document = CGPDFDocumentCreateWithProvider(provider);
-    CGDataProviderRelease(provider);
-    if (document == NULL) {
-      PdfCanvasFail(
-          error, PdfCanvasErrorCodeCorrupt,
-          @"CoreGraphics could not parse the document bytes — they carry a "
-          @"%PDF- header but no usable cross-reference table or page tree.",
-          nil);
-      return nil;
-    }
-    const BOOL unlocked =
-        UnlockCGDocument(document, password, @"the document", error);
-    if (!unlocked) {
-      CGPDFDocumentRelease(document);
-      return nil;
-    }
-    [leases addObject:[[PdfCanvasDocumentLease alloc] initWithDocument:document
-                                                              fileURL:nil
-                                                                 data:data
-                                                             password:password]];
-    CGPDFDocumentRelease(document);
-  }
-
-  return [self poolWithLeases:leases label:@"the document" error:error];
-}
-
-+ (nullable instancetype)poolWithLeases:
-                             (NSArray<PdfCanvasDocumentLease *> *)leases
-                                  label:(NSString *)label
-                                  error:(NSError *_Nullable *_Nullable)error {
-  const size_t pages =
-      CGPDFDocumentGetNumberOfPages(leases.firstObject.cgDocument);
-  if (pages == 0) {
-    // Reachable for a document that parsed but has an empty or unreadable page
-    // tree, and for one that is still locked — `CGPDFDocumentGetNumberOfPages`
-    // reports 0 rather than failing. The unlock above has already ruled the
-    // second out, so this is the first.
-    return PdfCanvasFail(
-        error, PdfCanvasErrorCodeCorrupt,
-        [NSString stringWithFormat:@"%@ reports 0 pages.", label], nil);
-  }
-  return [[self alloc] initWithLeases:leases pageCount:(NSInteger)pages];
-}
-
-- (instancetype)initWithLeases:(NSArray<PdfCanvasDocumentLease *> *)leases
-                     pageCount:(NSInteger)pageCount {
-  self = [super init];
-  if (self != nil) {
-    _free = [leases mutableCopy];
-    _lock = [[NSLock alloc] init];
-    _available = dispatch_semaphore_create((long)leases.count);
-    _pageCount = pageCount;
-    _size = (NSInteger)leases.count;
-  }
-  return self;
-}
-
-- (NSInteger)pageCount {
-  return _pageCount;
-}
-
-- (NSInteger)size {
-  return _size;
-}
-
-- (BOOL)isClosed {
-  [_lock lock];
-  const BOOL closed = _closed;
-  [_lock unlock];
-  return closed;
-}
-
-- (nullable PdfCanvasDocumentLease *)leaseWithError:
-    (NSError *_Nullable *_Nullable)error {
-  if (self.isClosed) {
-    return PdfCanvasFail(error, PdfCanvasErrorCodeBackendFailure,
-                         @"Document handle is closed.", nil);
-  }
-  dispatch_semaphore_wait(_available, DISPATCH_TIME_FOREVER);
-
-  [_lock lock];
-  PdfCanvasDocumentLease *lease = _free.lastObject;
-  if (lease != nil) {
-    [_free removeLastObject];
-  }
-  const BOOL closed = _closed;
-  [_lock unlock];
-
-  if (closed || lease == nil) {
-    // `close` raced us and emptied the free list. The count consumed above is
-    // handed back so a second waiter is not left blocked forever.
-    dispatch_semaphore_signal(_available);
-    return PdfCanvasFail(error, PdfCanvasErrorCodeBackendFailure,
-                         @"Document handle was closed while waiting for a lane.",
-                         nil);
-  }
-  return lease;
-}
-
-- (void)returnLease:(nullable PdfCanvasDocumentLease *)lease {
-  if (lease == nil) {
-    return;
-  }
-  [_lock lock];
-  // A lease returned to a CLOSED pool is dropped rather than re-queued, which is
-  // where its last reference goes and therefore where the parsed document is
-  // finally freed. The semaphore is still signalled: an unbalanced wait would
-  // wedge any render that raced the close.
-  const BOOL requeue = !_closed;
-  if (requeue) {
-    [_free addObject:lease];
-  }
-  [_lock unlock];
-  dispatch_semaphore_signal(_available);
-}
-
-- (void)close {
-  // Held OUTSIDE the lock, deliberately: `dropped` keeps the leases alive past
-  // the unlock so that releasing several parsed ARCH-E documents does not happen
-  // while a render worker might be waiting on the same lock. Assigning nil after
-  // the unlock is what forces that — ARC is free to shorten a local's lifetime to
-  // its last use, so relying on end-of-scope here would be relying on the
-  // optimiser not to do its job.
-  NSArray<PdfCanvasDocumentLease *> *dropped = nil;
-  [_lock lock];
-  if (_closed) {
-    [_lock unlock];
-    return;
-  }
-  _closed = YES;
-  // Dropping the FREE leases releases their documents. A lease that is currently
-  // OUT is untouched: the render worker owns it, and it is freed when
-  // `returnLease:` declines to re-queue it. Non-blocking, and with no window —
-  // see the header.
-  dropped = [_free copy];
-  [_free removeAllObjects];
-  [_lock unlock];
-  dropped = nil;
-}
-
-@end

package/ios/Sources/PdfCanvasCore/PdfCanvasErrorCode.m

@@ -1,57 +0,0 @@
-#import "PdfCanvasErrorCode.h"
-
-NSErrorDomain const PdfCanvasErrorDomain = @"tools.reekon.pdfcanvas";
-
-NSString *PdfCanvasErrorCodeWire(PdfCanvasErrorCode code) {
-  switch (code) {
-    case PdfCanvasErrorCodeNotFound:
-      return @"not-found";
-    case PdfCanvasErrorCodePasswordRequired:
-      return @"password-required";
-    case PdfCanvasErrorCodePasswordIncorrect:
-      return @"password-incorrect";
-    case PdfCanvasErrorCodeCorrupt:
-      return @"corrupt";
-    case PdfCanvasErrorCodeUnsupported:
-      return @"unsupported";
-    case PdfCanvasErrorCodeCancelled:
-      return @"cancelled";
-    case PdfCanvasErrorCodeOutOfMemory:
-      return @"out-of-memory";
-    case PdfCanvasErrorCodeBackendFailure:
-      return @"backend-failure";
-  }
-  // No `default:` above, so a new member is a compiler warning rather than a
-  // silent fall-through to this line. This exists only because the enum is an
-  // NSInteger and a caller could cast anything into it.
-  return @"backend-failure";
-}
-
-NSError *PdfCanvasMakeError(
-    PdfCanvasErrorCode code, NSString *message, NSError *_Nullable underlying) {
-  NSMutableDictionary<NSErrorUserInfoKey, id> *info =
-      [NSMutableDictionary dictionaryWithCapacity:3];
-  info[NSLocalizedDescriptionKey] = message ?: @"PDF Canvas failed.";
-  if (underlying != nil) {
-    info[NSUnderlyingErrorKey] = underlying;
-  }
-  return [NSError errorWithDomain:PdfCanvasErrorDomain code:code userInfo:info];
-}
-
-PdfCanvasErrorCode PdfCanvasErrorCodeOf(NSError *error) {
-  if (![error.domain isEqualToString:PdfCanvasErrorDomain]) {
-    return PdfCanvasErrorCodeBackendFailure;
-  }
-  return (PdfCanvasErrorCode)error.code;
-}
-
-id _Nullable PdfCanvasFail(
-    NSError *_Nullable *_Nullable out,
-    PdfCanvasErrorCode code,
-    NSString *message,
-    NSError *_Nullable underlying) {
-  if (out != NULL) {
-    *out = PdfCanvasMakeError(code, message, underlying);
-  }
-  return nil;
-}

package/ios/Sources/PdfCanvasCore/PdfCanvasPageGeometry.m

@@ -1,44 +0,0 @@
-#import "PdfCanvasPageGeometry.h"
-
-NSInteger PdfCanvasNormalizeRotation(NSInteger degrees) {
-  NSInteger wrapped = degrees % 360;
-  if (wrapped < 0) {
-    wrapped += 360;
-  }
-  return (wrapped % 90 == 0) ? wrapped : 0;
-}
-
-@implementation PdfCanvasPageGeometry
-
-- (instancetype)initWithIndex:(NSInteger)index
-                     cropBox:(CGRect)cropBox
-             rotationDegrees:(NSInteger)rotationDegrees {
-  self = [super init];
-  if (self != nil) {
-    _index = index;
-    _cropBox = cropBox;
-    _rotationDegrees = PdfCanvasNormalizeRotation(rotationDegrees);
-    // The one line of arithmetic that makes this type post-rotation. See the
-    // header: CoreGraphics reports the box unrotated, so nobody else does it.
-    const BOOL quarterTurn = (_rotationDegrees == 90 || _rotationDegrees == 270);
-    _widthPoints = quarterTurn ? cropBox.size.height : cropBox.size.width;
-    _heightPoints = quarterTurn ? cropBox.size.width : cropBox.size.height;
-  }
-  return self;
-}
-
-- (NSString *)description {
-  // The rect is formatted by hand rather than with `NSStringFromCGRect`, which
-  // lives in UIKit's UIGeometry.h and therefore does not exist on macOS — where
-  // this whole target is compiled by `ios/Package.swift` so that `swift test`
-  // can prove it without a device. Nothing in PdfCanvasCore may reach for UIKit.
-  return [NSString
-      stringWithFormat:@"PdfCanvasPageGeometry{%ld %gx%gpt rot=%ld "
-                       @"crop=(%g,%g %gx%g)}",
-                       (long)_index, _widthPoints, _heightPoints,
-                       (long)_rotationDegrees, _cropBox.origin.x,
-                       _cropBox.origin.y, _cropBox.size.width,
-                       _cropBox.size.height];
-}
-
-@end

package/ios/Sources/PdfCanvasCore/PdfCanvasPageTransform.m

@@ -1,82 +0,0 @@
-#import "PdfCanvasPageTransform.h"
-
-#import "PdfCanvasPageGeometry.h"
-
-/*
- * Every case below was derived by mapping the page's four corners and then
- * checked against a rendered fixture, so the derivation is worth keeping next to
- * the code.
- *
- * Write the unrotated page in y-DOWN box-local coordinates:
- *
- *     u = px - bx          in [0, bw]
- *     v = (by + bh) - py   in [0, bh]
- *
- * `/Rotate r` means "rotate the page r degrees CLOCKWISE when displayed", so the
- * displayed image is the (u, v) image turned clockwise by r. Turning an image
- * clockwise by 90 sends a source pixel at (u, v) to (H_src - v, u), where H_src is
- * the source HEIGHT, which is the rotated image's WIDTH. Substituting u and v
- * back gives each case:
- *
- *   r = 0     doc = (u, v)                 = (px - bx,               by + bh - py)
- *   r = 90    doc = (bh - v, u)            = (py - by,               px - bx)
- *   r = 180   doc = (bw - u, bh - v)       = (bw + bx - px,          py - by)
- *   r = 270   doc = (v, bw - u)            = (by + bh - py,          bw + bx - px)
- *
- * CGAffineTransform applies as `x' = a*x + c*y + tx`, `y' = b*x + d*y + ty`, so
- * `a` and `b` are the px column and `c` and `d` are the py column. Reading the
- * four expressions off that way is what the literals below are.
- *
- * Corner checks, for a 200 x 100 box at the origin:
- *
- *   r = 90,  PDF bottom-left  (0, 0)   -> doc (0, 0)       displayed TOP-LEFT
- *   r = 90,  PDF bottom-right (200, 0) -> doc (0, 200)     displayed BOTTOM-LEFT
- *   r = 180, PDF bottom-left  (0, 0)   -> doc (200, 0)     displayed TOP-RIGHT
- *   r = 270, PDF top-left     (0, 100) -> doc (0, 200)     displayed BOTTOM-LEFT
- *
- * All four match what turning a sheet of paper does, and all four are asserted
- * individually in the Swift suite rather than being inferred from a render.
- */
-CGAffineTransform PdfCanvasPdfToDocTransform(
-    CGRect cropBox, NSInteger rotationDegrees) {
-  const CGFloat bx = CGRectGetMinX(cropBox);
-  const CGFloat by = CGRectGetMinY(cropBox);
-  const CGFloat bw = CGRectGetWidth(cropBox);
-  const CGFloat bh = CGRectGetHeight(cropBox);
-
-  switch (PdfCanvasNormalizeRotation(rotationDegrees)) {
-    case 90:
-      // doc_x = py - by ; doc_y = px - bx
-      return CGAffineTransformMake(0, 1, 1, 0, -by, -bx);
-    case 180:
-      // doc_x = (bw + bx) - px ; doc_y = py - by
-      return CGAffineTransformMake(-1, 0, 0, 1, bw + bx, -by);
-    case 270:
-      // doc_x = (by + bh) - py ; doc_y = (bw + bx) - px
-      return CGAffineTransformMake(0, -1, -1, 0, by + bh, bw + bx);
-    case 0:
-    default:
-      // doc_x = px - bx ; doc_y = (by + bh) - py
-      return CGAffineTransformMake(1, 0, 0, -1, -bx, by + bh);
-  }
-}
-
-CGAffineTransform PdfCanvasDocToRasterTransform(
-    double docX, double docY, double scale, NSInteger pixelHeight) {
-  // The CG-op sequence this is the closed form of, for anyone checking it by
-  // hand: translate(0, H); scale(1, -1); scale(s, s); translate(-docX, -docY).
-  //
-  //   raster_x = (dx - docX) * s
-  //   raster_y = H - (dy - docY) * s
-  return CGAffineTransformMake(
-      (CGFloat)scale, 0, 0, (CGFloat)-scale, (CGFloat)(-docX * scale),
-      (CGFloat)((double)pixelHeight + docY * scale));
-}
-
-CGAffineTransform PdfCanvasDocToPdfKitTransform(double pageHeightPoints) {
-  // A pure y-flip through the page's own height, and nothing else: PDFKit
-  // applies the rotation and the box origin itself. See the header for the
-  // measurement that establishes both halves, and for why the height cannot come
-  // from `-[PDFPage boundsForBox:]`.
-  return CGAffineTransformMake(1, 0, 0, -1, 0, (CGFloat)pageHeightPoints);
-}

package/ios/Sources/PdfCanvasCore/PdfCanvasPixelSink.m

@@ -1,37 +0,0 @@
-#import "PdfCanvasPixelSink.h"
-
-@implementation PdfCanvasHeapSink {
-  NSMutableData *_data;
-  BOOL _reserved;
-}
-
-- (NSMutableData *)data {
-  return _data;
-}
-
-- (nullable void *)pdfCanvasReserveBytes:(NSUInteger)length {
-  if (_reserved || length == 0) {
-    return NULL;
-  }
-  _reserved = YES;
-  // `dataWithLength:` is documented to zero the bytes, which is the sink
-  // contract. It returns nil rather than raising when the allocation cannot be
-  // had, and NULL here is what the rasterizer maps to `out-of-memory`.
-  _data = [NSMutableData dataWithLength:length];
-  if (_data == nil) {
-    return NULL;
-  }
-  return _data.mutableBytes;
-}
-
-- (int64_t)pdfCanvasPublish {
-  // 0 is "heap-backed" on the wire — see `PdfCanvasRasterPixels.slot`. This sink
-  // has no identifier because `data` is how its bytes are reached.
-  return 0;
-}
-
-- (void)pdfCanvasAbandon {
-  _data = nil;
-}
-
-@end