librepdf 0.0.2

data/java/src/librepdf/Connection.java

@@ -0,0 +1,231 @@
+
+package librepdf;
+
+import librepdf.document.Factory;
+import librepdf.document.Document;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Map;
+import java.util.HashMap;
+import java.net.ConnectException;
+import org.jruby.*;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.javasupport.JavaEmbedUtils;
+
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.beans.PropertyValue;
+import com.sun.star.bridge.XBridge;
+import com.sun.star.bridge.XBridgeFactory;
+import com.sun.star.comp.helper.Bootstrap;
+import com.sun.star.connection.NoConnectException;
+import com.sun.star.connection.XConnection;
+import com.sun.star.connection.XConnector;
+import com.sun.star.frame.XComponentLoader;
+import com.sun.star.frame.XStorable;
+import com.sun.star.lang.EventObject;
+import com.sun.star.lang.XComponent;
+import com.sun.star.lang.XEventListener;
+import com.sun.star.lang.XMultiComponentFactory;
+import com.sun.star.task.ErrorCodeIOException;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+
+public final class Connection implements Closeable, Finalizable
+{
+    public static String DEFAULT_HOST = "127.0.0.1";
+    public static int    DEFAULT_PORT = 8100;
+  
+    private final Ruby   runtime;
+    private final String host;
+    private final int    port;
+  
+    private boolean closed = false;
+
+    private XComponent             bridgeComponent;
+    private XComponentContext      componentContext;
+    private XMultiComponentFactory serviceManager;
+
+    public Connection() throws ConnectException {
+        this(new HashMap<String, Object>(), null);
+    }
+
+    public Connection(RubyProc proc) throws ConnectException {
+        this(new HashMap<String, Object>(), proc);
+    }
+
+    public Connection(Map<String, Object> options) throws ConnectException {
+        this(options, null);
+    }
+
+    public Connection(Map<String, Object> options, RubyProc proc) throws ConnectException {
+        this.runtime = Ruby.getGlobalRuntime();
+        this.runtime.addInternalFinalizer(this);
+
+        if (options.containsKey("host")) {
+            this.host = options.get("host").toString();
+        } else {
+            this.host = DEFAULT_HOST;
+        }
+        if (options.containsKey("port")) {
+            final Object p = options.get("port");
+            if (!(p instanceof Long)) {
+                throw new IllegalArgumentException("The port required the number between 0-65535."); 
+            }
+
+            final Long l = (Long)p;
+            if (!(0 < l && l < 65536)) {
+                throw new IllegalArgumentException("The port required the number between 0-65535."); 
+            }
+            this.port = l.intValue();
+        } else {
+            this.port = DEFAULT_PORT;
+        }
+
+        this.open();
+        if (proc != null) {
+            try {
+                final ThreadContext context = this.runtime.getCurrentContext();
+                final IRubyObject[] args = { JavaEmbedUtils.javaToRuby(this.runtime, this) };
+                proc.call(context, args);
+            } finally {
+                try {
+                    this.close();
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        try {
+            this.close();
+        } catch(IOException e) {}
+    }
+
+    @Override
+    public synchronized void close() throws IOException {
+        if (!this.closed) {
+            this.bridgeComponent.dispose();
+            this.runtime.removeInternalFinalizer(this);
+            this.closed = true;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "#<Librepdf::Connection host=" + this.host + ",port=" + this.port + ">";
+    }
+
+    public boolean isClosed() {
+        return this.closed;
+    }
+
+    public String inspect() {
+        return this.toString();
+    }
+
+    private synchronized void open() throws ConnectException {
+        final String connectionString = "socket,host=" + this.host + ",port=" + this.port + ",tcpNoDelay=1";
+
+        try {
+            final XComponentContext localContext = Bootstrap.createInitialComponentContext(null);
+            final XMultiComponentFactory localServiceManager = localContext.getServiceManager();
+            final XConnector connector = (XConnector) UnoRuntime.queryInterface(XConnector.class, localServiceManager
+                    .createInstanceWithContext("com.sun.star.connection.Connector", localContext));
+            final XConnection connection = connector.connect(connectionString);
+            final XBridgeFactory bridgeFactory = (XBridgeFactory) UnoRuntime.queryInterface(XBridgeFactory.class,
+                    localServiceManager.createInstanceWithContext("com.sun.star.bridge.BridgeFactory", localContext));
+            final XBridge bridge = bridgeFactory.createBridge("", "urp", connection, null);
+
+            this.bridgeComponent = (XComponent) UnoRuntime.queryInterface(XComponent.class, bridge);
+            this.serviceManager = (XMultiComponentFactory) UnoRuntime.queryInterface(XMultiComponentFactory.class,
+                    bridge.getInstance("StarOffice.ServiceManager"));
+
+            final XPropertySet properties = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class,
+                    this.serviceManager);
+            this.componentContext = (XComponentContext) UnoRuntime.queryInterface(XComponentContext.class, properties
+                    .getPropertyValue("DefaultContext"));
+
+        } catch (Exception e) {
+            throw new ConnectException("connection failed: " + connectionString + ": " + e.getMessage());
+        }
+    }
+
+    public Document load(String inputUrl) {
+        return this.load(inputUrl, new HashMap<String, Object>());
+    }
+
+    public Document load(String inputUrl, Map<String, Object> options) {
+        if (inputUrl == null) {
+            throw new IllegalArgumentException("Null connot be set for inputUrl.");
+        }
+        if (this.closed) {
+            throw new IllegalArgumentException("The connection has not established it.");
+        }
+
+        options.put("Hidden", true);
+        options.put("ReadOnly", true);
+        final PropertyValue[] inputProperties = Utils.toPropertyValues(options);
+
+        final XComponent document = this.loadInternal(inputUrl, inputProperties);
+
+        return Factory.factory(this, this.runtime, document);
+    }
+
+    public Document load(String inputUrl, RubyProc proc) {
+        return this.load(inputUrl, new HashMap<String, Object>(), proc);
+    }
+
+    public Document load(String inputUrl, Map<String, Object> options, RubyProc proc) {
+        if (inputUrl == null) {
+            throw new IllegalArgumentException("Null connot be set for inputUrl.");
+        }
+        if (this.closed) {
+            throw new IllegalArgumentException("The connection has not established it.");
+        }
+
+        options.put("Hidden", true);
+        options.put("ReadOnly", true);
+        final PropertyValue[] inputProperties = Utils.toPropertyValues(options);
+
+        final XComponent document = this.loadInternal(inputUrl, inputProperties);
+
+        return Factory.factory(this, this.runtime, document, proc);
+    }
+
+    private XComponentLoader getDesktop() {
+        return (XComponentLoader) UnoRuntime.queryInterface(XComponentLoader.class,
+                this.getService("com.sun.star.frame.Desktop"));
+    }
+
+    private Object getService(String className) {
+        if (className == null) {
+            throw new IllegalArgumentException("Null connot be set for className.");
+        }
+
+        try {
+            return this.serviceManager.createInstanceWithContext(className, this.componentContext);
+
+        } catch (Exception e) {
+            throw new RuntimeException("could not obtain service: " + className, e);
+        }
+    }
+
+    private XComponent loadInternal(String inputUrl, PropertyValue[] properties) {
+        final XComponentLoader desktop = this.getDesktop();
+        try {
+            return desktop.loadComponentFromURL(inputUrl, "_blank", 0, properties);
+
+        } catch (ErrorCodeIOException e) {
+            throw new RuntimeException("could not load input document. " + e.ErrCode, e);
+
+        } catch (Exception e) {
+            throw new RuntimeException("could not load input document.", e);
+
+        }
+    }
+}
+

data/java/src/librepdf/Utils.java

@@ -0,0 +1,29 @@
+
+package librepdf;
+
+import java.util.Map;
+import java.util.Iterator;
+import com.sun.star.beans.PropertyValue;
+
+public final class Utils
+{
+    public static PropertyValue[] toPropertyValues(Map properties) {
+        final PropertyValue[] ret = new PropertyValue[properties.size()];
+        int i = 0;
+        for (Iterator it = properties.entrySet().iterator(); it.hasNext();) {
+            Map.Entry entry = (Map.Entry)it.next();
+            String key = entry.getKey().toString();
+            Object val = entry.getValue();
+
+            ret[i]       = new PropertyValue();
+            ret[i].Name  = key;
+            ret[i].Value = (val instanceof Map) ? Utils.toPropertyValues((Map)val) : val;
+
+            i++;
+        }
+        return ret;
+    }
+
+    private Utils() {}
+}
+

data/java/src/librepdf/document/Calc.java

@@ -0,0 +1,25 @@
+
+package librepdf.document;
+
+import librepdf.Connection;
+import java.util.Map;
+import org.jruby.Ruby;
+import org.jruby.RubyProc;
+import com.sun.star.lang.XComponent;
+
+class Calc extends Document
+{
+    Calc(Connection connection, Ruby runtime, XComponent document) {
+        super(connection, runtime, document);
+    }
+
+    Calc(Connection connection, Ruby runtime, XComponent document, RubyProc proc) {
+        super(connection, runtime, document, proc);
+    }
+
+    @Override
+    protected void setDefaultOptions(Map<String, Object> options) {
+        options.put("FilterName", "calc_pdf_Export");
+    }
+}
+

data/java/src/librepdf/document/Chart.java

@@ -0,0 +1,25 @@
+
+package librepdf.document;
+
+import librepdf.Connection;
+import java.util.Map;
+import org.jruby.Ruby;
+import org.jruby.RubyProc;
+import com.sun.star.lang.XComponent;
+
+class Chart extends Document
+{
+    Chart(Connection connection, Ruby runtime, XComponent document) {
+        super(connection, runtime, document);
+    }
+
+    Chart(Connection connection, Ruby runtime, XComponent document, RubyProc proc) {
+        super(connection, runtime, document, proc);
+    }
+
+    @Override
+    protected void setDefaultOptions(Map<String, Object> options) {
+        options.put("FilterName", "chart_pdf_Export");
+    }
+}
+

data/java/src/librepdf/document/Document.java

@@ -0,0 +1,124 @@
+
+package librepdf.document;
+
+import librepdf.Connection;
+import librepdf.Utils;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.io.Closeable;
+import java.io.IOException;
+import org.jruby.*;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.javasupport.JavaEmbedUtils;
+
+import com.sun.star.beans.PropertyValue;
+import com.sun.star.frame.XStorable;
+import com.sun.star.util.XCloseable;
+import com.sun.star.util.CloseVetoException;
+import com.sun.star.task.ErrorCodeIOException;
+import com.sun.star.lang.XComponent;
+import com.sun.star.lang.XServiceInfo;
+import com.sun.star.uno.UnoRuntime;
+
+public abstract class Document implements Closeable, Finalizable
+{
+    private final Connection    connection;
+    private final Ruby          runtime;
+    private final XComponent    document;
+
+    private boolean closed = false;
+
+    Document(Connection connection, Ruby runtime, XComponent document) {
+        this.connection = connection;
+        this.runtime    = runtime;
+        this.document   = document;
+        this.runtime.addInternalFinalizer(this);
+    }
+
+    Document(Connection connection, Ruby runtime, XComponent document, RubyProc proc) {
+        this(connection, runtime, document);
+
+        final ThreadContext context = this.runtime.getCurrentContext();
+        final IRubyObject[] args = { JavaEmbedUtils.javaToRuby(this.runtime, this) };
+
+        try {
+            proc.call(context, args);
+        } finally {
+            try {
+                this.close();
+            } catch (Exception e) {
+            }
+        }
+    }
+
+    @Override
+    public void finalize() throws Throwable {
+        try {
+            close();
+        } catch (IOException e) {}
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (!this.closed) {
+            final XCloseable closeable = (XCloseable) UnoRuntime.queryInterface(XCloseable.class, document);
+            try {
+                closeable.close(false);
+            } catch (CloseVetoException e) {
+                throw new IOException("chould not close document.", e);
+            }
+            this.runtime.removeInternalFinalizer(this);
+            this.closed = true;
+        }
+    }
+ 
+    public void convertPdf(String outputUrl) {
+        this.convertPdf(outputUrl, new HashMap<String, Object>());
+    }
+
+    public void convertPdf(String outputUrl, Map<String, Object> options) {
+        if (outputUrl == null) {
+            throw new IllegalArgumentException("Null connot be set for outputUrl.");
+        }
+        if (this.connection.isClosed()) {
+            throw new IllegalArgumentException("The connection has not established it.");
+        }
+
+        final XStorable storable = (XStorable) UnoRuntime.queryInterface(XStorable.class, document);
+ 
+        if (!options.containsKey("FilterData")) options.put("FilterData", new HashMap<String, Object>());
+        this.setDefaultOptions(options);
+        final PropertyValue[] outputProperties = Utils.toPropertyValues(options);
+
+        try {
+            storable.storeToURL(outputUrl, outputProperties);
+
+        } catch (ErrorCodeIOException e) {
+            throw new RuntimeException("could not save output document. " + e.ErrCode, e);
+
+        } catch (Exception e) {
+            throw new RuntimeException("could not save output document", e);
+
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "#<Librepdf::Document::" + this.getClass().getSimpleName() + ">";
+    }
+
+    public boolean isClosed() {
+        return this.closed;
+    }
+
+    public String inspect() {
+        return this.toString();
+    }
+
+    protected void setDefaultOptions(Map<String, Object> options) {
+        // do nothing.
+    }
+}
+

data/java/src/librepdf/document/Draw.java

@@ -0,0 +1,25 @@
+
+package librepdf.document;
+
+import librepdf.Connection;
+import java.util.Map;
+import org.jruby.Ruby;
+import org.jruby.RubyProc;
+import com.sun.star.lang.XComponent;
+
+class Draw extends Document
+{
+    Draw(Connection connection, Ruby runtime, XComponent document) {
+        super(connection, runtime, document);
+    }
+
+    Draw(Connection connection, Ruby runtime, XComponent document, RubyProc proc) {
+        super(connection, runtime, document, proc);
+    }
+
+    @Override
+    protected void setDefaultOptions(Map<String, Object> options) {
+        options.put("FilterName", "draw_pdf_Export");
+    }
+}
+