pdfium 0.0.1

data/ext/pdfium_ext/page_wrapper.cc

@@ -0,0 +1,86 @@
+#include "page_wrapper.h"
+#include "pdfium.h"
+
+CPDF_Page*
+RB2PG(VALUE self){
+    PageWrapper *page;
+    Data_Get_Struct(self, PageWrapper, page);
+    return page->page();
+}
+
+PageWrapper::PageWrapper(DocumentWrapper* doc, int page) :
+    document_wrapper(doc), _page_number(page), _in_use(true), _page(NULL)
+{
+    this->document_wrapper->retain(this);
+}
+
+void
+PageWrapper::unload(){
+    FPDF_ClosePage(_page);
+    _page = NULL;
+}
+
+
+// Mark the page object as no longer in use.  At this
+// point it may be freed once all children are also not
+// in use
+void
+PageWrapper::markUnused(){
+    _in_use = false;
+    this->unload();
+    this->maybeKillSelf();
+}
+
+void
+PageWrapper::setPage(CPDF_Page *page){
+    if (_page){
+        this->unload();
+    }
+    // unload won't work if the page has children
+    if (!_page){
+        this->_page=page;
+    }
+}
+
+void
+PageWrapper::retain(void *obj){
+    _children.insert(obj);
+}
+
+CPDF_Page *
+PageWrapper::page(){
+    if (!_page){
+        _page = static_cast<CPDF_Page *>(FPDF_LoadPage(document_wrapper->document, _page_number));
+    }
+    return _page;
+}
+
+void
+PageWrapper::release(void *obj){
+    _children.erase(obj);
+    this->maybeKillSelf();
+
+}
+
+// Test if the Document is not in use and there are no pages
+// that are still retained
+void
+PageWrapper::maybeKillSelf(){
+    bool killable = _children.empty() && !_in_use;
+    DEBUG_MSG("Testing if killing Page: " << this << " " << killable );
+    if (killable){
+        delete this;
+    }
+}
+
+// void
+// PageWrapper::wrap(CPDF_Page *pg, DocumentWrapper *doc_wrapper){
+//     this->page = pg;
+//     this->doc  = doc_wrapper;
+//     this->doc->retain(this);
+// }
+
+
+PageWrapper::~PageWrapper(){
+    this->unload();
+}

data/ext/pdfium_ext/page_wrapper.h

@@ -0,0 +1,37 @@
+#ifndef __PAGE_WRAPPER_H__
+#define __PAGE_WRAPPER_H__
+
+#include "pdfium.h"
+#include <unordered_set>
+
+class DocumentWrapper;
+
+class PageWrapper {
+
+  public:
+
+    PageWrapper(DocumentWrapper* doc, int page);
+    void wrap(CPDF_Page *page, DocumentWrapper *doc_wrapper);
+    ~PageWrapper();
+
+    void markUnused();
+
+    void retain(void *obj);
+    void release(void *obj);
+
+    CPDF_Page *page();
+    void unload();
+    void setPage(CPDF_Page *pg);
+
+    DocumentWrapper *document_wrapper;
+    int _page_number;
+  private:
+
+    bool _in_use;
+    CPDF_Page *_page;
+    std::unordered_set<void*> _children;
+    void maybeKillSelf();
+};
+
+
+#endif // __PAGE_WRAPPER_H__

data/ext/pdfium_ext/pdfium.cc

@@ -0,0 +1,115 @@
+#include <iostream>
+#include <string>
+
+#include "pdfium.h"
+extern "C" {
+#include "ruby/encoding.h"
+}
+
+#include <assert.h>
+#include <list>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "document.h"
+#include "page.h"
+
+// // file local variables that are set in Init_pdfium_ext function
+// // and are referenced elsewhere in file
+// static VALUE rb_page;  // Ruby definition of the Page class
+
+const char*
+PDFiumLastErrorString() {
+    switch(FPDF_GetLastError()){
+    case 0:
+        return "No Error";
+    case 1:
+        return "unknown error";
+    case 2:
+        return "file not found or could not be opened";
+    case 3:
+        return "file not in PDF format or corrupted";
+    case 4:
+        return "password required or incorrect password";
+    case 5:
+        return "unsupported security scheme";
+    case 6:
+        return "page not found or content error";
+    default:
+        return "error code unknown";
+    }
+}
+
+
+VALUE _get(const char *name){
+    return rb_const_get(RB::PDFium(), rb_intern(name));
+}
+VALUE RB::PDFium(){
+    static VALUE val = rb_const_get(rb_cObject, rb_intern("PDFium"));
+    return val;
+}
+VALUE RB::Page(){
+    static VALUE val = _get("Page");
+    return val;
+}
+VALUE RB::Image(){
+    static VALUE val = _get("Image");
+    return val;
+}
+VALUE RB::BoundingBox(){
+    static VALUE val = _get("BoundingBox");
+    return val;
+}
+VALUE RB::Bookmark(){
+    static VALUE val = _get("Bookmark");
+    return val;
+}
+VALUE RB::Document(){
+    static VALUE val = _get("Document");
+    return val;
+}
+VALUE RB::BookmarkList(){
+    static VALUE val = _get("BookmarkList");
+    return val;
+}
+VALUE RB::PageList(){
+    static VALUE val = _get("PageList");
+    return val;
+}
+VALUE RB::ImageList(){
+    static VALUE val = _get("ImageList");
+    return val;
+}
+
+VALUE
+RB::to_string(const CFX_WideString &wstr){
+    static rb_encoding *enc = rb_enc_find("UTF-16LE");
+    return rb_enc_str_new(wstr.UTF16LE_Encode().c_str(),(wstr.GetLength()*2), enc);
+}
+
+ID RB::to_s(VALUE obj){
+    static ID id = rb_intern("to_s");
+    return rb_funcall(obj, id, 0);
+}
+
+VALUE RB::type(VALUE obj){
+    static ID id = rb_intern("class");
+    return rb_funcall(obj, id, 0);
+}
+
+VALUE RB::get_option(VALUE options, const std::string &key){
+    return rb_hash_aref(options, ID2SYM(rb_intern(key.c_str())));
+}
+
+extern "C" void
+Init_pdfium_ext()
+{
+    // Initialize the PDFium library
+    FPDF_InitLibrary();
+
+    define_document_class();
+    define_page_class();
+    define_bookmark_class();
+    define_image_class();
+}

data/ext/pdfium_ext/pdfium.h

@@ -0,0 +1,69 @@
+#ifndef __PDFIUM_H__
+#define __PDFIUM_H__
+
+#include <stdlib.h>
+#include <inttypes.h>
+#include <fpdf_dataavail.h>
+#include <fpdf_ext.h>
+#include <fpdfformfill.h>
+#include <fpdftext.h>
+#include <fpdfview.h>
+#include <fpdfedit.h>
+#include <fpdfsave.h>
+#include <fpdfdoc.h>
+#include <iostream>
+#include <fpdfdoc/fpdf_doc.h>
+
+#include <fpdfapi/fpdf_render.h>
+#include <fpdfapi/fpdf_pageobj.h>
+#include <fpdfsdk/include/fsdk_rendercontext.h>
+#include <FreeImage.h>
+
+#include "page_wrapper.h"
+#include "page_object_wrapper.h"
+#include "document_wrapper.h"
+
+// auto generated by mkmf
+#include "extconf.h"
+extern "C" {
+#include "ruby.h"
+}
+
+#ifdef DEBUG
+#define DEBUG_MSG(str) do { std::cout << str << std::endl; } while( false )
+#else
+#define DEBUG_MSG(str) do { } while ( false )
+#endif
+
+VALUE define_bookmark_class();
+VALUE define_document_class();
+VALUE define_page_class();
+VALUE define_image_class();
+
+// a utility method to extract the reference to the FPDF_DOCUMENT from the Ruby/C++ wrapping
+
+CPDF_Page*        RB2PG(VALUE RB_Page);
+CPDF_Document*    RB2DOC(VALUE RB_DocumentWrapper);
+CPDF_ImageObject* RB2IMG(VALUE RB_Image);
+
+const char* PDFiumLastErrorString();
+
+class RB {
+ public:
+    static VALUE PDFium();
+    static VALUE Bookmark();
+    static VALUE Document();
+    static VALUE Page();
+    static VALUE BookmarkList();
+    static VALUE BoundingBox();
+    static VALUE StringIO();
+    static VALUE Image();
+    static VALUE PageList();
+    static VALUE ImageList();
+    static VALUE type(VALUE object);
+    static VALUE to_string(const CFX_WideString &widestring);
+    static ID to_s(VALUE object);
+    static VALUE get_option(VALUE hash, const std::string &key);
+};
+
+#endif // __PDFIUM_H__

data/lib/pdfium.rb

@@ -0,0 +1,15 @@
+require 'stringio'
+require_relative "pdfium/version"
+require_relative "pdfium/bookmark_list"
+require_relative "pdfium/page_list"
+require_relative "pdfium/page_sizes"
+require_relative "pdfium/bounding_box"
+require_relative "pdfium/image_list"
+
+
+# PDFium is an Ruby interface to the Google PDFium PDF renderer.
+module PDFium
+
+end
+
+require_relative "pdfium_ext"

data/lib/pdfium/bookmark_list.rb

@@ -0,0 +1,28 @@
+module PDFium
+
+    # A list of bookmarks for a Document or a Bookmark
+    class BookmarkList
+
+        include Enumerable
+        # Not used directly, but called from Document#bookmarks
+        def initialize(initial)
+            @first=initial
+        end
+
+        # Calls block once for each bookmark that exists at the current level
+        # Since bookmarks form a tree, each bookmark may have one or more children
+        def each
+            bookmark = @first
+            while bookmark
+                yield bookmark
+                bookmark = bookmark.next_sibling
+            end
+        end
+
+        # True if no bookmarks exist, false if at least one is present
+        def empty?
+            @first.nil?
+        end
+    end
+
+end

data/lib/pdfium/bounding_box.rb

@@ -0,0 +1,16 @@
+module PDFium
+
+    # The size of an object.  Used with both Page and Image
+    class BoundingBox
+
+        # dimensions for the BoundingBox.  Fixnum given in terms of points
+        attr_reader :left, :right, :top, :bottom
+
+        # Left, Right, Top, Bottom
+        def initialize(l,r,t,b)
+            @left=l; @right=r; @top=t; @bottom=b
+        end
+
+  end
+
+end

data/lib/pdfium/image_list.rb

@@ -0,0 +1,21 @@
+module PDFium
+
+    # A list of Image instances for a given Page.  Is returned by Page#images
+    # Images are lazily loaded upon request.
+    class ImageList
+
+        include Enumerable
+
+        # Load list for a given page.  Not normally called directly, but from Page#images
+        def initialize(page)
+            @page=page
+        end
+
+        # Calls block once for each object on the document
+        def each(&block)
+            @page.each_image(&block)
+        end
+
+    end
+
+end

data/lib/pdfium/page_list.rb

@@ -0,0 +1,36 @@
+module PDFium
+
+    # A list of Page objects associated with a Document.
+    class PageList
+
+        include Enumerable
+
+        # Create a new listing from the given document.
+        # Not normally called directly, is called internally by Document#pages
+        def initialize(document)
+            @document=document
+        end
+
+        # Calls block once for each page on the document, yielding the current page
+        # After the page is yielded, Page#unload will be automatically called.
+        #
+        # _note_ Subsequent calls to this function will return different Page instances.
+        def each(&block)
+            @document.each_page(&block)
+        end
+
+        # Returns the number of pages on the document
+        def count
+            @document.page_count
+        end
+
+        # Returns a Page instance for the given number.
+        # If the given page_number is not valid, an ArgumentError will be raised.
+        #
+        # _note_ Subsequent calls to this function will return different Page instances.
+        def [](index)
+            @document.page_at(index)
+        end
+    end
+
+end

data/lib/pdfium/page_sizes.rb

@@ -0,0 +1,7 @@
+module PDFium
+    # Standard A4 paper size
+    A4 = [ 595, 842 ]
+    # Standard US Letter size
+    LETTER = [612,792]
+
+end

data/lib/pdfium/version.rb

@@ -0,0 +1,4 @@
+module PDFium
+    # Gem version
+    VERSION = "0.0.1"
+end