Enable / fix iOS module, closes #29

.gitignore

@@ -3,6 +3,7 @@
 */obj/*
 target/
 build/
+robovm-build
 *.o
 *.so
 *.class

settings.gradle

@@ -14,4 +14,4 @@ include ':vtm-android-gdx'
 //include ':vtm-web-js'
 include ':vtm-jeo'
 include ':vtm-playground'
-//include ':vtm-ios'
+include ':vtm-ios'

vtm-ios/build.gradle

@@ -1,69 +1,72 @@
 buildscript {
   repositories {
+    mavenLocal()
     mavenCentral()
-  }
-
-  dependencies {
-    classpath 'com.github.jtakakura:gradle-robovm-plugin:0.0.4'
-  }
-}
-
-repositories {
     maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
+    jcenter()
+  }
+  dependencies {
+    classpath 'com.mobidevelop.robovm:robovm-gradle-plugin:2.1.0'
+  }
 }
 
-apply plugin: 'java'
+apply plugin: "java"
-apply plugin: 'robovm'
+apply plugin: "robovm"
+
+sourceSets.main.java.srcDirs = ["src/"]
+
+sourceCompatibility = '1.7'
+[compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
 
 ext {
   // Configure your application main class
   mainClassName = "org.oscim.ios.RoboVmLauncher"
-  //roboVMVersion = "0.0.9"
+  roboVMVersion = "2.1.0"
 }
 
+launchIPhoneSimulator.dependsOn build
+launchIPadSimulator.dependsOn build
+launchIOSDevice.dependsOn build
+createIPA.dependsOn build
+
 dependencies {
+  compile project(':vtm')
   compile project(':vtm-gdx')
   compile project(':vtm-themes')
   compile 'org.slf4j:slf4j-simple:1.7.5'
+  compile "com.mobidevelop.robovm:robovm-rt:$roboVMVersion"
+  compile "com.mobidevelop.robovm:robovm-cocoatouch:$roboVMVersion"
   compile "com.badlogicgames.gdx:gdx-backend-robovm:$gdxVersion"
+  compile "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-ios"
 }
 
 
-sourceCompatibility = '1.7'
-//[compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
 
-robovm {
+
-  // Configure robovm
+
-  iosSignIdentity = ""
+task copyLibs(type: Copy){
-  iosProvisioningProfile = ""
+  from (zipTree("vtm-natives-ios.jar"))
+  into ("${buildDir}/natives")
 }
 
-sourceSets {
+task copyVtmResources(type: Copy){
-  main {
+    from ("../vtm/resources")
-    java.srcDirs = ['src/']
+    into ("${buildDir}")
-    //resources.srcDirs = ['src/', 'data']
-  }
-  output.resourcesDir = 'assets'
 }
 
-// compile bytecode to llvm and run in the ios simulator
+task copyVtmThemesResources(type: Copy){
-// task run (dependsOn: compileJava){
+    from ("../vtm-themes/resources")
-//   doFirst {
+    into ("${buildDir}")
-//     println(">> Running RoboVM")
-//     String cmd = "$project.robovm_home/bin/robovm -verbose -arch x86 -os ios -cp $project.robovm_home/lib/robovm-objc.jar:$project.robovm_home/lib/robovm-cocoatouch.jar:$projectDir/build/classes/main/ -run $mainClass"
-//     def proc = cmd.execute()
-
-//     proc.in.eachLine {line -> println line}
-//     proc.err.eachLine {line -> System.err.println( 'ERROR: ' + line)}
-//     proc.waitFor()
-//   }
-// }
-
-
-eclipse {
-  project {
-    natures = [  'org.eclipse.jdt.core.javanature',
-		 'org.robovm.eclipse.RoboVMNature']
-    buildCommand 'org.robovm.eclipse.RoboVMClassBuilder'
 }
+
+tasks.withType(org.gradle.api.tasks.compile.JavaCompile){
+  compileTask -> compileTask.dependsOn copyLibs
+}
+
+tasks.withType(org.gradle.api.tasks.compile.JavaCompile){
+    compileTask -> compileTask.dependsOn copyVtmResources
+}
+
+tasks.withType(org.gradle.api.tasks.compile.JavaCompile){
+    compileTask -> compileTask.dependsOn copyVtmThemesResources
 }

vtm-ios/robovm.properties

@@ -1,7 +1,7 @@
 #
 #Fri May 31 13:01:40 CEST 2013
 app.version=1.0
-app.id=com.noxymo.opensciencemap
+app.id=de.longri.libgdx.mapsforge
 app.mainclass=org.oscim.ios.RobovmLauncher
 app.executable=VtmApp
 app.build=1

vtm-ios/robovm.xml

@@ -7,7 +7,7 @@
     <iosInfoPList>Info.plist.xml</iosInfoPList>
     <resources>
         <resource>
-      <directory>../vtm-themes/resources/assets</directory>
+            <directory>./build/assets</directory>
             <includes>
                 <include>**</include>
             </includes>
@@ -19,11 +19,21 @@
     </resources>
     <forceLinkClasses>
         <pattern>com.badlogic.gdx.scenes.scene2d.ui.*</pattern>
+        <pattern>com.badlogic.gdx.graphics.g3d.particles.**</pattern>
+        <pattern>com.android.okhttp.HttpHandler</pattern>
+        <pattern>com.android.okhttp.HttpsHandler</pattern>
+        <pattern>com.android.org.conscrypt.**</pattern>
+        <pattern>com.android.org.bouncycastle.jce.provider.BouncyCastleProvider</pattern>
+        <pattern>com.android.org.bouncycastle.jcajce.provider.keystore.BC$Mappings</pattern>
+        <pattern>com.android.org.bouncycastle.jcajce.provider.keystore.bc.BcKeyStoreSpi</pattern>
+        <pattern>com.android.org.bouncycastle.jcajce.provider.keystore.bc.BcKeyStoreSpi$Std</pattern>
+        <pattern>com.android.org.bouncycastle.jce.provider.PKIXCertPathValidatorSpi</pattern>
+        <pattern>com.android.org.bouncycastle.crypto.digests.AndroidDigestFactoryOpenSSL</pattern>
+        <pattern>org.apache.harmony.security.provider.cert.DRLCertFactory</pattern>
+        <pattern>org.apache.harmony.security.provider.crypto.CryptoProvider</pattern>
     </forceLinkClasses>
     <libs>
-    <lib>../vtm-ext-libs/ios/libgdx.a</lib>
+        <lib>build/natives/libvtm-jni.a</lib>
-    <lib>../vtm-ext-libs/ios/libObjectAL.a</lib>
-    <lib>../vtm-ext-libs/ios/libvtm-jni.a</lib>
     </libs>
     <frameworks>
         <framework>UIKit</framework>

vtm-ios/src/org/oscim/ios/IOSMapApp.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2013 Hannes Janetzek
+ * Copyright 2016 Longri
+ *
+ * This file is part of the OpenScienceMap project (http://www.opensciencemap.org).
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.oscim.ios;
+
+
+import org.oscim.backend.GLAdapter;
+import org.oscim.gdx.GdxAssets;
+import org.oscim.gdx.GdxMap;
+import org.oscim.ios.backend.IosGL;
+import org.oscim.ios.backend.IosGraphics;
+
+
+public class IOSMapApp extends GdxMap {
+
+    public static void init() {
+
+        // init globals
+        IosGraphics.init();
+        GdxAssets.init("assets/");
+        GLAdapter.init(new IosGL());
+    }
+}

vtm-ios/src/org/oscim/ios/RobovmLauncher.java

@@ -1,56 +1,68 @@
 package org.oscim.ios;
 
-import org.oscim.backend.GLAdapter;
-import org.oscim.gdx.GdxMap;
-import org.oscim.ios.backend.IosGLAdapter;
-import org.oscim.ios.backend.IosGraphics;
-import org.oscim.layers.tile.buildings.BuildingLayer;
-import org.oscim.layers.tile.vector.VectorTileLayer;
-import org.oscim.layers.tile.vector.labeling.LabelLayer;
-import org.oscim.theme.VtmThemes;
-import org.oscim.tiling.TileSource;
-import org.oscim.tiling.source.oscimap4.OSciMap4TileSource;
-import org.robovm.apple.glkit.GLKViewDrawableStencilFormat;
-import org.robovm.cocoatouch.foundation.NSAutoreleasePool;
-import org.robovm.cocoatouch.uikit.UIApplication;
-
 import com.badlogic.gdx.backends.iosrobovm.IOSApplication;
 import com.badlogic.gdx.backends.iosrobovm.IOSApplicationConfiguration;
+import org.oscim.backend.CanvasAdapter;
+import org.oscim.layers.tile.buildings.BuildingLayer;
+import org.oscim.layers.tile.vector.VectorTileLayer;
+import org.oscim.layers.tile.vector.labeling.LabelLayer;
+import org.oscim.map.Map;
+import org.oscim.theme.VtmThemes;
+import org.oscim.tiling.source.oscimap4.OSciMap4TileSource;
+import org.robovm.apple.foundation.NSAutoreleasePool;
+import org.robovm.apple.glkit.GLKViewDrawableStencilFormat;
+import org.robovm.apple.uikit.UIApplication;
+import org.robovm.apple.uikit.UIDevice;
+import org.robovm.apple.uikit.UIScreen;
 
 public class RobovmLauncher extends IOSApplication.Delegate {
+
     @Override
     protected IOSApplication createApplication() {
+
         IOSApplicationConfiguration config = new IOSApplicationConfiguration();
         config.orientationLandscape = true;
         config.orientationPortrait = true;
         config.stencilFormat = GLKViewDrawableStencilFormat._8;
 
-		return new IOSApplication(new GdxMap() {
+        float scale = (float)(getIosVersion() >= 8 ? UIScreen.getMainScreen().getNativeScale() : UIScreen.getMainScreen()
+                .getScale());
+
+        CanvasAdapter.dpi *= scale;
+
+        IOSMapApp iosMapApp = new IOSMapApp() {
             @Override
             public void createLayers() {
-				TileSource tileSource = new OSciMap4TileSource();
+                Map map = getMap();
 
-				//initDefaultLayers(tileSource, false,true, false);
-				VectorTileLayer l = mMap.setBaseMap(tileSource);
-				mMap.setTheme(VtmThemes.NEWTRON);
-				mMap.layers().add(new BuildingLayer(mMap, l));
-				mMap.layers().add(new LabelLayer(mMap, l));
 
-				// mMap.getLayers().add(new GenericLayer(mMap, new
+                VectorTileLayer l = map.setBaseMap(new OSciMap4TileSource());
-				// GridRenderer(1,new Line(Color.LTGRAY, 1.2f),null)));
 
-				mMap.setMapPosition(53.1, 8.8, 1 << 14);
+                map.layers().add(new BuildingLayer(map, l));
+                map.layers().add(new LabelLayer(map, l));
+
+                map.setTheme(VtmThemes.DEFAULT);
+                map.setMapPosition(53.075, 8.808, 1 << 17);
             }
 
-		}, config);
+        };
+
+        IOSMapApp.init();
+
+        return new IOSApplication(iosMapApp, config);
     }
 
+
+    private int getIosVersion () {
+        String systemVersion = UIDevice.getCurrentDevice().getSystemVersion();
+        return Integer.parseInt(systemVersion.split("\\.")[0]);
+    }
+
+
     public static void main(String[] argv) {
-
         NSAutoreleasePool pool = new NSAutoreleasePool();
         System.setProperty(org.slf4j.impl.SimpleLogger.DEFAULT_LOG_LEVEL_KEY, "TRACE");
-		IosGraphics.init();
+        IOSMapApp.init();
-		GLAdapter.init(new IosGLAdapter());
 
         UIApplication.main(argv, null, RobovmLauncher.class);
         pool.drain();

vtm-ios/src/org/oscim/ios/backend/IosBitmap.java

@@ -1,77 +1,219 @@
+/*
+ * Copyright 2016 Longri
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.oscim.ios.backend;
 
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Pixmap;
+import org.oscim.backend.AssetAdapter;
+import org.oscim.backend.GL;
+import org.oscim.backend.canvas.Bitmap;
+import org.oscim.backend.canvas.Color;
+import org.robovm.apple.coregraphics.*;
+import org.robovm.apple.foundation.NSData;
+import org.robovm.apple.uikit.UIColor;
+import org.robovm.apple.uikit.UIImage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 
-import org.oscim.backend.GL20;
+/**
-import org.oscim.backend.canvas.Bitmap;
+ * iOS specific implementation of {@link Bitmap}<br>
-
+ * <br>
-import com.badlogic.gdx.Gdx;
+ * Created by Longri on 25.06.16.
-import com.badlogic.gdx.files.FileHandle;
+ */
-import com.badlogic.gdx.graphics.Pixmap;
-import com.badlogic.gdx.graphics.g2d.Gdx2DPixmap;
-
 public class IosBitmap implements Bitmap {
 
+    static final Logger log = LoggerFactory.getLogger(IosBitmap.class);
+
+    final CGBitmapContext cgBitmapContext;
+    final int width;
+    final int height;
     Pixmap pixmap;
-	boolean disposable;
 
-	/** always argb8888 */
+    /**
+     * Constructor<br>
+     * Create a IosBitmap with given width and height. <br>
+     * The format is ignored and set always to ARGB8888
+     *
+     * @param width
+     * @param height
+     * @param format ignored always ARGB8888
+     */
     public IosBitmap(int width, int height, int format) {
-		pixmap = new Pixmap(width, height, Pixmap.Format.RGBA8888);
+        this.width = width;
-	}
+        this.height = height;
-
+        this.cgBitmapContext = CGBitmapContext.create(width, height, 8, 4 * width,
-	public IosBitmap(String fileName) {
+                CGColorSpace.createDeviceRGB(), CGImageAlphaInfo.PremultipliedLast);
-		FileHandle handle = Gdx.files.internal(fileName);
-		pixmap = new Pixmap(handle);
-		disposable = true;
     }
 
+    /**
+     * Constructor<br>
+     * Create a IosBitmap from given InputStream
+     *
+     * @param inputStream
+     * @throws IOException
+     */
     public IosBitmap(InputStream inputStream) throws IOException {
-		pixmap = new Pixmap(new Gdx2DPixmap(inputStream, Gdx2DPixmap.GDX2D_FORMAT_RGBA8888));
+        NSData data = new NSData(toByteArray(inputStream));
+        CGImage image = new UIImage(data).getCGImage();
+        this.width = (int) image.getWidth();
+        this.height = (int) image.getHeight();
+        this.cgBitmapContext = CGBitmapContext.create(width, height, 8, 4 * width,
+                CGColorSpace.createDeviceRGB(), CGImageAlphaInfo.PremultipliedLast);
+
+        this.cgBitmapContext.drawImage(new CGRect(0, 0, width, height), image);
+        image.dispose();
     }
 
+    /**
+     * Constructor<br>
+     * Load a IosBitmap from Asset with given FilePath
+     *
+     * @param fileName
+     * @throws IOException
+     */
+    public IosBitmap(String fileName) throws IOException {
+        if (fileName == null || fileName.length() == 0) {
+            // no image source defined
+            this.cgBitmapContext = null;
+            this.width = 0;
+            this.height = 0;
+            return;
+        }
+
+        InputStream inputStream = AssetAdapter.readFileAsStream(fileName);
+        if (inputStream == null) {
+            log.error("invalid bitmap source: " + fileName);
+            // no image source defined
+            this.cgBitmapContext = null;
+            this.width = 0;
+            this.height = 0;
+            return;
+        }
+
+        NSData data = new NSData(toByteArray(inputStream));
+        CGImage image = new UIImage(data).getCGImage();
+        this.width = (int) image.getWidth();
+        this.height = (int) image.getHeight();
+        this.cgBitmapContext = CGBitmapContext.create(width, height, 8, 4 * width,
+                CGColorSpace.createDeviceRGB(), CGImageAlphaInfo.PremultipliedLast);
+
+        this.cgBitmapContext.drawImage(new CGRect(0, 0, width, height), image);
+        image.dispose();
+    }
+
+
     @Override
     public int getWidth() {
-		return pixmap.getWidth();
+        return this.width;
     }
 
     @Override
     public int getHeight() {
-		return pixmap.getHeight();
+        return this.height;
     }
 
     @Override
     public void recycle() {
-		// FIXME this should be called at some point in time
+        if (this.cgBitmapContext != null) this.cgBitmapContext.release();
-		pixmap.dispose();
+        if (this.pixmap != null) this.pixmap.dispose();
-
     }
 
     @Override
     public int[] getPixels() {
-		return null;
+        //Todo fill a int[] with pixmap.getPixel(x,y)
+        return new int[0];
     }
 
     @Override
     public void eraseColor(int color) {
+
+        //delete all pixels and fill with given color
+
+        CGRect rect = new CGRect(0, 0, this.width, this.height);
+        this.cgBitmapContext.setFillColor(getCGColor(color));
+        this.cgBitmapContext.setBlendMode(CGBlendMode.Clear);
+        this.cgBitmapContext.fillRect(rect);
+        this.cgBitmapContext.setBlendMode(CGBlendMode.Normal);
+        this.cgBitmapContext.fillRect(rect);
     }
 
     @Override
     public void uploadToTexture(boolean replace) {
 
-		Gdx.gl.glTexImage2D(GL20.TEXTURE_2D, 0, pixmap.getGLInternalFormat(),
+        //create Pixmap from cgBitmapContext
+        UIImage uiImage = new UIImage(cgBitmapContext.toImage());
+        NSData data = uiImage.toPNGData();
+        byte[] encodedData = data.getBytes();
+
+        if (pixmap != null) {
+            // release outdated native pixel buffer
+            pixmap.dispose();
+        }
+
+        pixmap = new Pixmap(encodedData, 0, encodedData.length);
+
+        Gdx.gl.glTexImage2D(GL.TEXTURE_2D, 0, pixmap.getGLInternalFormat(),
                 pixmap.getWidth(), pixmap.getHeight(), 0,
                 pixmap.getGLFormat(), pixmap.getGLType(),
                 pixmap.getPixels());
 
-		if (disposable) {
+        data.dispose();
-			pixmap.dispose();
+        uiImage.dispose();
-		}
+        encodedData = null;
+
     }
 
     @Override
     public boolean isValid() {
-		return true;
+        return this.cgBitmapContext != null;
+    }
+
+
+    /**
+     * Returns a ByteArray from InputStream
+     *
+     * @param in InputStream
+     * @return
+     * @throws IOException
+     */
+    static byte[] toByteArray(InputStream in) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] buff = new byte[8192];
+        while (in.read(buff) > 0) {
+            out.write(buff);
+        }
+        out.close();
+        return out.toByteArray();
+    }
+
+    /**
+     * Returns the CGColor from given int
+     *
+     * @param color
+     * @return
+     */
+    static CGColor getCGColor(int color) {
+        return UIColor.fromRGBA(
+                Color.a(color),
+                Color.g(color),
+                Color.b(color),
+                Color.r(color))
+                .getCGColor();
     }
 }

vtm-ios/src/org/oscim/ios/backend/IosCanvas.java

@@ -1,78 +1,64 @@
+/*
+ * Copyright 2016 Longri
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.oscim.ios.backend;
 
 import org.oscim.backend.canvas.Bitmap;
 import org.oscim.backend.canvas.Canvas;
 import org.oscim.backend.canvas.Paint;
+import org.robovm.apple.coregraphics.CGBitmapContext;
+import org.robovm.apple.coregraphics.CGRect;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import com.badlogic.gdx.graphics.Pixmap;
+/**
-import com.badlogic.gdx.graphics.TextureData;
+ * iOS specific implementation of {@link Canvas}<br>
-import com.badlogic.gdx.graphics.g2d.BitmapFont;
+ * <br>
-import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph;
+ * Created by Longri on 25.06.16.
-
+ */
 public class IosCanvas implements Canvas {
 
-	IosBitmap bitmap;
+    static final Logger log = LoggerFactory.getLogger(IosCanvas.class);
-	static BitmapFont font = new BitmapFont();
 
-	public IosCanvas() {
+    CGBitmapContext cgBitmapContext;
-		// canvas comes with gdx pixmap
-	}
 
     @Override
     public void setBitmap(Bitmap bitmap) {
-		this.bitmap = (IosBitmap) bitmap;
+        cgBitmapContext = ((IosBitmap) bitmap).cgBitmapContext;
-		this.bitmap.pixmap.setColor(0);
-		this.bitmap.pixmap.fill();
     }
 
     @Override
-	public void drawText(String string, float x, float y, Paint paint) {
+    public void drawText(String string, float x, float y, Paint fill, Paint stroke) {
-		if (bitmap == null) {
+
-			// log.debug("no bitmap set");
+        //flip Y-axis
-			return;
+        y = this.cgBitmapContext.getHeight() - y;
-		}
+
-
+        IosPaint iosFill = (IosPaint) fill;
-		// IosPaint p = (IosPaint) paint;
+        if (stroke != null) {
-
+            IosPaint iosStroke = (IosPaint) stroke;
-		Pixmap pixmap = bitmap.pixmap;
+            iosFill.setStrokeWidth(iosStroke.strokeWidth);
-
+            iosFill.setStrokeColor(iosStroke.getColor());
-		TextureData td = font.getRegion().getTexture().getTextureData();
-		if (!td.isPrepared())
-			td.prepare();
-
-		Pixmap f = td.consumePixmap();
-
-		int adv = (int) x;
-		Glyph last = null;
-
-		int ch = (int) font.getCapHeight();
-		int h = (int) font.getLineHeight();
-		int yy = (int) (y - font.getLineHeight());
-		if (y < 0)
-			y = 0;
-
-		// pixmap.setColor(0xff0000ff);
-		// int w = (int) font.getBounds(string).width;
-		// pixmap.drawRectangle((int) x - 4, (int) y - 4, w + 8, h + 8);
-
-		for (int i = 0; i < string.length(); i++) {
-			char c = string.charAt(i);
-			Glyph g = font.getData().getGlyph(c);
-			if (g == null)
-				g = font.getData().getGlyph(' ');
-
-			if (i > 0)
-				adv += last.getKerning(c);
-			pixmap.drawPixmap(f, adv, //- g.xoffset,
-			                  yy - (g.height + g.yoffset) - (h - ch),
-			                  g.srcX, g.srcY,
-			                  g.width, g.height);
-			adv += g.width;
-			last = g;
         }
+        iosFill.drawLine(this.cgBitmapContext, string, x, y);
     }
 
     @Override
     public void drawBitmap(Bitmap bitmap, float x, float y) {
+        this.cgBitmapContext.saveGState();
+        this.cgBitmapContext.translateCTM(x, y);
+        this.cgBitmapContext.drawImage(new CGRect(0, 0, bitmap.getWidth(), bitmap.getHeight()),
+                ((IosBitmap) bitmap).cgBitmapContext.toImage());
+        this.cgBitmapContext.restoreGState();
     }
 }

vtm-ios/src/org/oscim/ios/backend/IosGL.java

@@ -0,0 +1,745 @@
+/*
+ * Copyright 2016 Longri
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.oscim.ios.backend;
+
+import com.badlogic.gdx.backends.iosrobovm.IOSGLES20;
+
+import org.oscim.backend.GL;
+
+import java.nio.Buffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+/**
+ * iOS specific implementation of {@link GL}<br>
+ * <br>
+ * Created by Longri on 25.06.16.
+ */
+public class IosGL implements GL {
+
+    private static final IOSGLES20 iOSGL = new IOSGLES20();
+
+    public void activeTexture(int texture) {
+        iOSGL.glActiveTexture(texture);
+    }
+
+    public void bindTexture(int target, int texture) {
+        iOSGL.glBindTexture(target, texture);
+    }
+
+    public void blendFunc(int sfactor, int dfactor) {
+        iOSGL.glBlendFunc(sfactor, dfactor);
+    }
+
+    public void clear(int mask) {
+        iOSGL.glClear(mask);
+    }
+
+    public void clearColor(float red, float green, float blue, float alpha) {
+        iOSGL.glClearColor(red, green, blue, alpha);
+    }
+
+    public void clearDepthf(float depth) {
+        iOSGL.glClearDepthf(depth);
+    }
+
+    public void clearStencil(int s) {
+        iOSGL.glClearStencil(s);
+    }
+
+    public void colorMask(boolean red, boolean green, boolean blue, boolean alpha) {
+        iOSGL.glColorMask(red, green, blue, alpha);
+    }
+
+    public void compressedTexImage2D(int target, int level, int internalformat, int width,
+                                     int height, int border,
+                                     int imageSize, Buffer data) {
+        iOSGL.glCompressedTexImage2D(
+                target,
+                level,
+                internalformat,
+                width,
+                height,
+                border,
+                imageSize,
+                data);
+    }
+
+    public void compressedTexSubImage2D(int target, int level, int xoffset, int yoffset,
+                                        int width, int height, int format,
+                                        int imageSize, Buffer data) {
+        iOSGL.glCompressedTexSubImage2D(
+                target,
+                level,
+                xoffset,
+                yoffset,
+                width,
+                height,
+                format,
+                imageSize,
+                data);
+    }
+
+    public void copyTexImage2D(int target, int level, int internalformat, int x, int y,
+                               int width, int height, int border) {
+        iOSGL.glCopyTexImage2D(
+                target,
+                level,
+                internalformat,
+                x,
+                y,
+                width,
+                height,
+                border);
+    }
+
+    public void copyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y,
+                                  int width, int height) {
+        iOSGL.glCopyTexSubImage2D(
+                target,
+                level,
+                xoffset,
+                yoffset,
+                x,
+                y,
+                width,
+                height);
+    }
+
+    public void cullFace(int mode) {
+        iOSGL.glCullFace(mode);
+    }
+
+    public void deleteTextures(int n, IntBuffer textures) {
+        iOSGL.glDeleteTextures(n, textures);
+    }
+
+    public void depthFunc(int func) {
+        iOSGL.glDepthFunc(func);
+    }
+
+    public void depthMask(boolean flag) {
+        iOSGL.glDepthMask(flag);
+    }
+
+    public void depthRangef(float zNear, float zFar) {
+        iOSGL.glDepthRangef(zNear, zFar);
+    }
+
+    public void disable(int cap) {
+        iOSGL.glDisable(cap);
+    }
+
+    public void drawArrays(int mode, int first, int count) {
+        iOSGL.glDrawArrays(mode, first, count);
+    }
+
+    public void drawElements(int mode, int count, int type, Buffer indices) {
+        iOSGL.glDrawElements(mode, count, type, indices);
+    }
+
+    public void enable(int cap) {
+        iOSGL.glEnable(cap);
+    }
+
+    public void finish() {
+        iOSGL.glFinish();
+    }
+
+    public void flush() {
+        iOSGL.glFlush();
+    }
+
+    public void frontFace(int mode) {
+        iOSGL.glFrontFace(mode);
+    }
+
+    public void genTextures(int n, IntBuffer textures) {
+        iOSGL.glGenTextures(n, textures);
+    }
+
+    public int getError() {
+        return iOSGL.glGetError();
+    }
+
+    public void getIntegerv(int pname, IntBuffer params) {
+        iOSGL.glGetIntegerv(pname, params);
+    }
+
+    public String getString(int name) {
+        return iOSGL.glGetString(name);
+    }
+
+    public void hint(int target, int mode) {
+        iOSGL.glHint(target, mode);
+    }
+
+    public void lineWidth(float width) {
+        iOSGL.glLineWidth(width);
+    }
+
+    public void pixelStorei(int pname, int param) {
+        iOSGL.glPixelStorei(pname, param);
+    }
+
+    public void polygonOffset(float factor, float units) {
+        iOSGL.glPolygonOffset(factor, units);
+    }
+
+    public void readPixels(int x, int y, int width, int height, int format, int type,
+                           Buffer pixels) {
+        iOSGL.glReadPixels(
+                x,
+                y,
+                width,
+                height,
+                format,
+                type,
+                pixels);
+    }
+
+    public void scissor(int x, int y, int width, int height) {
+        iOSGL.glScissor(x, y, width, height);
+    }
+
+    public void stencilFunc(int func, int ref, int mask) {
+        iOSGL.glStencilFunc(func, ref, mask);
+    }
+
+    public void stencilMask(int mask) {
+        iOSGL.glStencilMask(mask);
+    }
+
+    public void stencilOp(int fail, int zfail, int zpass) {
+        iOSGL.glStencilOp(fail, zfail, zpass);
+    }
+
+    public void texImage2D(int target, int level, int internalFormat, int width, int height,
+                           int border, int format, int type,
+                           Buffer pixels) {
+        iOSGL.glTexImage2D(
+                target,
+                level,
+                internalFormat,
+                width,
+                height,
+                border,
+                format,
+                type,
+                pixels);
+    }
+
+    public void texParameterf(int target, int pname, float param) {
+        iOSGL.glTexParameterf(target, pname, param);
+    }
+
+    public void texSubImage2D(int target, int level, int xoffset, int yoffset, int width,
+                              int height, int format, int type,
+                              Buffer pixels) {
+        iOSGL.glTexSubImage2D(
+                target,
+                level,
+                xoffset,
+                yoffset,
+                width,
+                height,
+                format,
+                type,
+                pixels);
+    }
+
+    public void viewport(int x, int y, int width, int height) {
+        iOSGL.glViewport(x, y, width, height);
+    }
+
+    public void getFloatv(int pname, FloatBuffer params) {
+        iOSGL.glGetFloatv(pname, params);
+    }
+
+    public void getTexParameterfv(int target, int pname, FloatBuffer params) {
+        iOSGL.glGetTexParameterfv(target, pname, params);
+    }
+
+    public void texParameterfv(int target, int pname, FloatBuffer params) {
+        iOSGL.glTexParameterfv(target, pname, params);
+    }
+
+    public void bindBuffer(int target, int buffer) {
+        iOSGL.glBindBuffer(target, buffer);
+    }
+
+    public void bufferData(int target, int size, Buffer data, int usage) {
+        iOSGL.glBufferData(target, size, data, usage);
+    }
+
+    public void bufferSubData(int target, int offset, int size, Buffer data) {
+        iOSGL.glBufferSubData(target, offset, size, data);
+    }
+
+    public void deleteBuffers(int n, IntBuffer buffers) {
+        iOSGL.glDeleteBuffers(n, buffers);
+    }
+
+    public void getBufferParameteriv(int target, int pname, IntBuffer params) {
+        iOSGL.glGetBufferParameteriv(target, pname, params);
+    }
+
+    public void genBuffers(int n, IntBuffer buffers) {
+        iOSGL.glGenBuffers(n, buffers);
+    }
+
+    public void getTexParameteriv(int target, int pname, IntBuffer params) {
+        iOSGL.glGetTexParameteriv(target, pname, params);
+    }
+
+    public boolean isBuffer(int buffer) {
+        return iOSGL.glIsBuffer(buffer);
+    }
+
+    public boolean isEnabled(int cap) {
+        return iOSGL.glIsEnabled(cap);
+    }
+
+    public boolean isTexture(int texture) {
+        return iOSGL.glIsTexture(texture);
+    }
+
+    public void texParameteri(int target, int pname, int param) {
+        iOSGL.glTexParameteri(target, pname, param);
+    }
+
+    public void texParameteriv(int target, int pname, IntBuffer params) {
+        iOSGL.glTexParameteriv(target, pname, params);
+    }
+
+    public void drawElements(int mode, int count, int type, int indices) {
+        iOSGL.glDrawElements(mode, count, type, indices);
+    }
+
+    public void attachShader(int program, int shader) {
+        iOSGL.glAttachShader(program, shader);
+    }
+
+    public void bindAttribLocation(int program, int index, String name) {
+        iOSGL.glBindAttribLocation(program, index, name);
+    }
+
+    public void bindFramebuffer(int target, int framebuffer) {
+        iOSGL.glBindFramebuffer(target, framebuffer);
+    }
+
+    public void bindRenderbuffer(int target, int renderbuffer) {
+        iOSGL.glBindRenderbuffer(target, renderbuffer);
+    }
+
+    public void blendColor(float red, float green, float blue, float alpha) {
+        iOSGL.glBlendColor(red, green, blue, alpha);
+    }
+
+    public void blendEquation(int mode) {
+        iOSGL.glBlendEquation(mode);
+    }
+
+    public void blendEquationSeparate(int modeRGB, int modeAlpha) {
+        iOSGL.glBlendEquationSeparate(modeRGB, modeAlpha);
+    }
+
+    public void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
+        iOSGL.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+    }
+
+    public int checkFramebufferStatus(int target) {
+        return iOSGL.glCheckFramebufferStatus(target);
+    }
+
+    public void compileShader(int shader) {
+        iOSGL.glCompileShader(shader);
+    }
+
+    public int createProgram() {
+        return iOSGL.glCreateProgram();
+    }
+
+    public int createShader(int type) {
+        return iOSGL.glCreateShader(type);
+    }
+
+    public void deleteFramebuffers(int n, IntBuffer framebuffers) {
+        iOSGL.glDeleteFramebuffers(n, framebuffers);
+    }
+
+    public void deleteProgram(int program) {
+        iOSGL.glDeleteProgram(program);
+    }
+
+    public void deleteRenderbuffers(int n, IntBuffer renderbuffers) {
+        iOSGL.glDeleteRenderbuffers(
+                n,
+                renderbuffers);
+    }
+
+    public void deleteShader(int shader) {
+        iOSGL.glDeleteShader(shader);
+    }
+
+    public void detachShader(int program, int shader) {
+        iOSGL.glDetachShader(program, shader);
+    }
+
+    public void disableVertexAttribArray(int index) {
+        iOSGL.glDisableVertexAttribArray(index);
+    }
+
+    public void enableVertexAttribArray(int index) {
+        iOSGL.glEnableVertexAttribArray(index);
+    }
+
+    public void framebufferRenderbuffer(int target, int attachment, int renderbuffertarget,
+                                        int renderbuffer) {
+        iOSGL.glFramebufferRenderbuffer(
+                target,
+                attachment,
+                renderbuffertarget,
+                renderbuffer);
+    }
+
+    public void framebufferTexture2D(int target, int attachment, int textarget, int texture,
+                                     int level) {
+        iOSGL.glFramebufferTexture2D(
+                target,
+                attachment,
+                textarget,
+                texture,
+                level);
+    }
+
+    public void generateMipmap(int target) {
+        iOSGL.glGenerateMipmap(target);
+    }
+
+    public void genFramebuffers(int n, IntBuffer framebuffers) {
+        iOSGL.glGenFramebuffers(n, framebuffers);
+    }
+
+    public void genRenderbuffers(int n, IntBuffer renderbuffers) {
+        iOSGL
+                .glGenRenderbuffers(n, renderbuffers);
+    }
+
+    public String getActiveAttrib(int program, int index, IntBuffer size, Buffer type) {
+        return iOSGL.glGetActiveAttrib(
+                program,
+                index,
+                size,
+                type);
+    }
+
+    public String getActiveUniform(int program, int index, IntBuffer size, Buffer type) {
+        return iOSGL.glGetActiveUniform(
+                program,
+                index,
+                size,
+                type);
+    }
+
+    public void getAttachedShaders(int program, int maxcount, Buffer count, IntBuffer shaders) {
+        iOSGL.glGetAttachedShaders(
+                program,
+                maxcount,
+                count,
+                shaders);
+    }
+
+    public int getAttribLocation(int program, String name) {
+        return iOSGL.glGetAttribLocation(program, name);
+    }
+
+    public void getBooleanv(int pname, Buffer params) {
+        iOSGL.glGetBooleanv(pname, params);
+    }
+
+    public void getFramebufferAttachmentParameteriv(int target, int attachment, int pname,
+                                                    IntBuffer params) {
+        iOSGL.glGetFramebufferAttachmentParameteriv(
+                target,
+                attachment,
+                pname,
+                params);
+    }
+
+    public void getProgramiv(int program, int pname, IntBuffer params) {
+        iOSGL.glGetProgramiv(program, pname, params);
+    }
+
+    public String getProgramInfoLog(int program) {
+        return iOSGL.glGetProgramInfoLog(program);
+    }
+
+    public void getRenderbufferParameteriv(int target, int pname, IntBuffer params) {
+        iOSGL.glGetRenderbufferParameteriv(
+                target,
+                pname,
+                params);
+    }
+
+    public void getShaderiv(int shader, int pname, IntBuffer params) {
+        iOSGL.glGetShaderiv(shader, pname, params);
+    }
+
+    public String getShaderInfoLog(int shader) {
+        return iOSGL.glGetShaderInfoLog(shader);
+    }
+
+    public void getShaderPrecisionFormat(int shadertype, int precisiontype, IntBuffer range,
+                                         IntBuffer precision) {
+        iOSGL.glGetShaderPrecisionFormat(
+                shadertype,
+                precisiontype,
+                range,
+                precision);
+    }
+
+    public void getShaderSource(int shader, int bufsize, Buffer length, String source) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public void getUniformfv(int program, int location, FloatBuffer params) {
+        iOSGL.glGetUniformfv(program, location, params);
+    }
+
+    public void getUniformiv(int program, int location, IntBuffer params) {
+        iOSGL.glGetUniformiv(program, location, params);
+    }
+
+    public int getUniformLocation(int program, String name) {
+        return iOSGL.glGetUniformLocation(program, name);
+    }
+
+    public void getVertexAttribfv(int index, int pname, FloatBuffer params) {
+        iOSGL.glGetVertexAttribfv(index, pname, params);
+    }
+
+    public void getVertexAttribiv(int index, int pname, IntBuffer params) {
+        iOSGL.glGetVertexAttribiv(index, pname, params);
+    }
+
+    public void getVertexAttribPointerv(int index, int pname, Buffer pointer) {
+        iOSGL.glGetVertexAttribPointerv(
+                index,
+                pname,
+                pointer);
+    }
+
+    public boolean isFramebuffer(int framebuffer) {
+        return iOSGL.glIsFramebuffer(framebuffer);
+    }
+
+    public boolean isProgram(int program) {
+        return iOSGL.glIsProgram(program);
+    }
+
+    public boolean isRenderbuffer(int renderbuffer) {
+        return iOSGL.glIsRenderbuffer(renderbuffer);
+    }
+
+    public boolean isShader(int shader) {
+        return iOSGL.glIsShader(shader);
+    }
+
+    public void linkProgram(int program) {
+        iOSGL.glLinkProgram(program);
+    }
+
+    public void releaseShaderCompiler() {
+        iOSGL.glReleaseShaderCompiler();
+    }
+
+    public void renderbufferStorage(int target, int internalformat, int width, int height) {
+        iOSGL.glRenderbufferStorage(target, internalformat, width, height);
+    }
+
+    public void sampleCoverage(float value, boolean invert) {
+        iOSGL.glSampleCoverage(value, invert);
+    }
+
+    public void shaderBinary(int n, IntBuffer shaders, int binaryformat, Buffer binary, int length) {
+        iOSGL.glShaderBinary(
+                n,
+                shaders,
+                binaryformat,
+                binary,
+                length);
+    }
+
+    public void shaderSource(int shader, String string) {
+        iOSGL.glShaderSource(shader, string);
+    }
+
+    public void stencilFuncSeparate(int face, int func, int ref, int mask) {
+        iOSGL.glStencilFuncSeparate(face, func, ref, mask);
+    }
+
+    public void stencilMaskSeparate(int face, int mask) {
+        iOSGL.glStencilMaskSeparate(face, mask);
+    }
+
+    public void stencilOpSeparate(int face, int fail, int zfail, int zpass) {
+        iOSGL.glStencilOpSeparate(face, fail, zfail, zpass);
+    }
+
+    public void uniform1f(int location, float x) {
+        iOSGL.glUniform1f(location, x);
+    }
+
+    public void uniform1fv(int location, int count, FloatBuffer v) {
+        iOSGL.glUniform1fv(location, count, v);
+    }
+
+    public void uniform1i(int location, int x) {
+        iOSGL.glUniform1i(location, x);
+    }
+
+    public void uniform1iv(int location, int count, IntBuffer v) {
+        iOSGL.glUniform1iv(location, count, v);
+    }
+
+    public void uniform2f(int location, float x, float y) {
+        iOSGL.glUniform2f(location, x, y);
+    }
+
+    public void uniform2fv(int location, int count, FloatBuffer v) {
+        iOSGL.glUniform2fv(location, count, v);
+    }
+
+    public void uniform2i(int location, int x, int y) {
+        iOSGL.glUniform2i(location, x, y);
+    }
+
+    public void uniform2iv(int location, int count, IntBuffer v) {
+        iOSGL.glUniform2iv(location, count, v);
+    }
+
+    public void uniform3f(int location, float x, float y, float z) {
+        iOSGL.glUniform3f(location, x, y, z);
+    }
+
+    public void uniform3fv(int location, int count, FloatBuffer v) {
+        iOSGL.glUniform3fv(location, count, v);
+    }
+
+    public void uniform3i(int location, int x, int y, int z) {
+        iOSGL.glUniform3i(location, x, y, z);
+    }
+
+    public void uniform3iv(int location, int count, IntBuffer v) {
+        iOSGL.glUniform3iv(location, count, v);
+    }
+
+    public void uniform4f(int location, float x, float y, float z, float w) {
+        iOSGL.glUniform4f(location, x, y, z, w);
+    }
+
+    public void uniform4fv(int location, int count, FloatBuffer v) {
+        iOSGL.glUniform4fv(location, count, v);
+    }
+
+    public void uniform4i(int location, int x, int y, int z, int w) {
+        iOSGL.glUniform4i(location, x, y, z, w);
+    }
+
+    public void uniform4iv(int location, int count, IntBuffer v) {
+        iOSGL.glUniform4iv(location, count, v);
+    }
+
+    public void uniformMatrix2fv(int location, int count, boolean transpose, FloatBuffer value) {
+        iOSGL.glUniformMatrix2fv(
+                location,
+                count,
+                transpose,
+                value);
+    }
+
+    public void uniformMatrix3fv(int location, int count, boolean transpose, FloatBuffer value) {
+        iOSGL.glUniformMatrix3fv(
+                location,
+                count,
+                transpose,
+                value);
+    }
+
+    public void uniformMatrix4fv(int location, int count, boolean transpose, FloatBuffer value) {
+        iOSGL.glUniformMatrix4fv(
+                location,
+                count,
+                transpose,
+                value);
+    }
+
+    public void useProgram(int program) {
+        iOSGL.glUseProgram(program);
+    }
+
+    public void validateProgram(int program) {
+        iOSGL.glValidateProgram(program);
+    }
+
+    public void vertexAttrib1f(int indx, float x) {
+        iOSGL.glVertexAttrib1f(indx, x);
+    }
+
+    public void vertexAttrib1fv(int indx, FloatBuffer values) {
+        iOSGL.glVertexAttrib1fv(indx, values);
+    }
+
+    public void vertexAttrib2f(int indx, float x, float y) {
+        iOSGL.glVertexAttrib2f(indx, x, y);
+    }
+
+    public void vertexAttrib2fv(int indx, FloatBuffer values) {
+        iOSGL.glVertexAttrib2fv(indx, values);
+    }
+
+    public void vertexAttrib3f(int indx, float x, float y, float z) {
+        iOSGL.glVertexAttrib3f(indx, x, y, z);
+    }
+
+    public void vertexAttrib3fv(int indx, FloatBuffer values) {
+        iOSGL.glVertexAttrib3fv(indx, values);
+    }
+
+    public void vertexAttrib4f(int indx, float x, float y, float z, float w) {
+        iOSGL.glVertexAttrib4f(indx, x, y, z, w);
+    }
+
+    public void vertexAttrib4fv(int indx, FloatBuffer values) {
+        iOSGL.glVertexAttrib4fv(indx, values);
+    }
+
+    public void vertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
+                                    Buffer ptr) {
+        iOSGL.glVertexAttribPointer(
+                indx,
+                size,
+                type,
+                normalized,
+                stride,
+                ptr);
+    }
+
+    public void vertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
+                                    int ptr) {
+        iOSGL.glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
+    }
+}

vtm-ios/src/org/oscim/ios/backend/IosGLAdapter.java

@@ -1,9 +0,0 @@
-package org.oscim.ios.backend;
-
-import org.oscim.backend.GL20;
-
-import com.badlogic.gdx.backends.iosrobovm.IOSGLES20;
-
-public class IosGLAdapter extends IOSGLES20 implements GL20 {
-
-}

vtm-ios/src/org/oscim/ios/backend/IosGraphics.java

@@ -1,3 +1,17 @@
+/*
+ * Copyright 2016 Longri
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.oscim.ios.backend;
 
 import java.io.IOException;
@@ -8,53 +22,54 @@ import org.oscim.backend.canvas.Bitmap;
 import org.oscim.backend.canvas.Canvas;
 import org.oscim.backend.canvas.Paint;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * iOS specific implementation of {@link CanvasAdapter}<br>
+ * <br>
+ * Created by Longri on 25.06.16.
+ */
 public class IosGraphics extends CanvasAdapter {
 
-	private static final IosGraphics INSTANCE = new IosGraphics();
+	static final Logger log = LoggerFactory.getLogger(IosGraphics.class);
-
-	public static CanvasAdapter get() {
-		return INSTANCE;
-	}
 
 	public static void init() {
-		g = INSTANCE;
+		CanvasAdapter.init(new IosGraphics());
 	}
 
 	@Override
-	public Canvas getCanvas() {
+	protected Canvas newCanvasImpl() {
 		return new IosCanvas();
 	}
 
 	@Override
-	public Paint getPaint() {
+	protected Paint newPaintImpl() {
 		return new IosPaint();
 	}
 
 	@Override
-	public Bitmap getBitmap(int width, int height, int format) {
+	protected Bitmap newBitmapImpl(int width, int height, int format) {
 		return new IosBitmap(width, height, format);
 	}
 
 	@Override
-	public Bitmap decodeBitmap(InputStream inputStream) {
+	protected Bitmap decodeBitmapImpl(InputStream inputStream) {
 		try {
 			return new IosBitmap(inputStream);
 		} catch (IOException e) {
-			e.printStackTrace();
+			log.error("decodeBitmapImpl",e);
 			return null;
 		}
 	}
 
 	@Override
-	public Bitmap loadBitmapAsset(String fileName) {
+	protected Bitmap loadBitmapAssetImpl(String fileName) {
+		try {
 			return new IosBitmap(fileName);
-
+		} catch (IOException e) {
-		//		try {
+			log.error("loadBitmapAssetImpl",e);
-		//			return createBitmap(fileName);
+			return null;
-		//		} catch (IOException e) {
+		}
-		//			e.printStackTrace();
-		//		}
-		//		return null;
 	}
-
 }

vtm-ios/src/org/oscim/ios/backend/IosPaint.java

@@ -1,55 +1,326 @@
+/*
+ * Copyright 2016 Longri
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.oscim.ios.backend;
 
 import org.oscim.backend.canvas.Paint;
 
+import org.robovm.apple.coregraphics.CGAffineTransform;
+import org.robovm.apple.coregraphics.CGBitmapContext;
+import org.robovm.apple.coregraphics.CGBlendMode;
+import org.robovm.apple.coregraphics.CGLineCap;
+import org.robovm.apple.coretext.CTFont;
+import org.robovm.apple.coretext.CTLine;
+import org.robovm.apple.foundation.NSAttributedString;
+import org.robovm.apple.uikit.NSAttributedStringAttributes;
+import org.robovm.apple.uikit.UIColor;
+import org.robovm.apple.uikit.UIFont;
+import org.robovm.apple.uikit.UIFontWeight;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+
+
+/**
+ * iOS specific implementation of {@link Paint}<br>
+ * <br>
+ * Created by Longri on 25.06.16.
+ */
 public class IosPaint implements Paint {
+    private static final Logger log = LoggerFactory.getLogger(IosPaint.class);
+
+    private static final String DEFAULT_FONT_NAME = UIFont.getSystemFont(1, UIFontWeight.Semibold).getFontDescriptor().getPostscriptName();
+    private static final String DEFAULT_FONT_NAME_BOLD = UIFont.getSystemFont(1, UIFontWeight.Bold).getFontDescriptor().getPostscriptName();
+    private static final String DEFAULT_FONT_NAME_ITALIC = UIFont.getItalicSystemFont(1).getFontDescriptor().getPostscriptName();
+
+    private final NSAttributedStringAttributes attribs = new NSAttributedStringAttributes();
+    private CGLineCap cap = CGLineCap.Butt;
+    private Style style;
+    private float textSize;
+    private FontFamily fontFamily;
+    private FontStyle fontStyle;
+    private int colorInt;
+    private int strokeColorInt;
+    private CTLine ctLine;
+    private boolean ctLineIsDirty = true;
+    private String lastText = "";
+    private float descent;
+    private float fontHeight;
+    private final static HashMap<String, UIFont> fontHashMap = new HashMap<>();
+
+    float strokeWidth;
 
     @Override
     public int getColor() {
-		return 0;
+        return this.colorInt;
     }
 
     @Override
     public void setColor(int color) {
+        if (colorInt == color) return;
+        this.colorInt = color;
+        synchronized (attribs) {
+            attribs.setForegroundColor(getUiColor(color));
+        }
+        ctLineIsDirty = true;
+    }
+
+    public void setStrokeColor(int color) {
+        if (strokeColorInt == color) return;
+        this.strokeColorInt = color;
+        synchronized (attribs) {
+            attribs.setStrokeColor(getUiColor(color));
+        }
+        ctLineIsDirty = true;
+    }
+
+    private UIColor getUiColor(int color) {
+        float colorA = ((color & 0xff000000) >>> 24) / 255f;
+        float colorR = ((color & 0xff0000) >>> 16) / 255f;
+        float colorG = ((color & 0xff00) >>> 8) / 255f;
+        float colorB = (color & 0xff) / 255f;
+        return new UIColor(colorR, colorG, colorB, colorA);
     }
 
     @Override
     public void setStrokeCap(Cap cap) {
+        this.cap = getLineCap(cap);
     }
 
+
     @Override
     public void setStrokeWidth(float width) {
+        if (this.strokeWidth == width) return;
+        this.strokeWidth = width;
+        this.ctLineIsDirty = true;
     }
 
     @Override
     public void setStyle(Style style) {
+        this.style = style;
     }
 
     @Override
     public void setTextAlign(Align align) {
+// TODO: set Align
     }
 
     @Override
     public void setTextSize(float textSize) {
+        if (this.textSize != textSize) {
+            this.textSize = textSize;
+            createIosFont();
+            ctLineIsDirty = true;
+        }
     }
 
     @Override
     public void setTypeface(FontFamily fontFamily, FontStyle fontStyle) {
+        if (fontFamily != this.fontFamily
+                || fontStyle != this.fontStyle) {
+
+            this.fontFamily = fontFamily;
+            this.fontStyle = fontStyle;
+            createIosFont();
+            ctLineIsDirty = true;
         }
+    }
+
 
     @Override
     public float measureText(String text) {
-		return IosCanvas.font.getBounds(text).width;
+        if (ctLineIsDirty || !text.equals(lastText)) {
+            ctLineIsDirty = true;
+            createCTLine(text);
+        }
+        return (float) ctLine.getWidth();
+    }
+
+
+    private void createCTLine(String text) {
+        if (ctLineIsDirty) {
+            synchronized (attribs) {
+                /*
+                The sign of the value for NSStrokeWidthAttributeName is interpreted as a mode;
+                it indicates whether the attributed string is to be filled, stroked, or both.
+                Specifically, a zero value displays a fill only, while a positive value displays a stroke only.
+                A negative value allows displaying both a fill and stroke.
+
+                !!!!!
+                NOTE: The value of NSStrokeWidthAttributeName is interpreted as a percentage of the font point size.
+                */
+                float strokeWidthPercent = -(this.strokeWidth / this.textSize * 50);
+                attribs.setStrokeWidth(strokeWidthPercent);
+
+                NSAttributedString attributedString = new NSAttributedString(text, attribs);
+                ctLine = CTLine.create(attributedString);
+                attributedString.dispose();
+            }
+            lastText = text;
+            ctLineIsDirty = false;
+        }
+    }
+
+
+    private void createIosFont() {
+
+        /*
+          DEVICE_DEFAULT = [iOS == getDeviceDefault()], [Android == 'Roboto']
+          MONOSPACE      = [iOS == 'Courier'], [Android == 'Droid Sans Mono']
+          SANS_SERIF     = [iOS == 'Verdena'], [Android == 'Droid Sans']
+          SERIF          = [iOS == 'Georgia'], [Android == 'Droid Serif']
+         */
+
+
+        String fontname = DEFAULT_FONT_NAME;
+        switch (this.fontFamily) {
+            case DEFAULT:
+                // set Style
+                switch (this.fontStyle) {
+                    case NORMAL:
+                        fontname = DEFAULT_FONT_NAME;
+                        break;
+                    case BOLD:
+                        fontname = DEFAULT_FONT_NAME_BOLD;
+                        break;
+                    case BOLD_ITALIC:
+                        fontname = DEFAULT_FONT_NAME_BOLD;
+                        break;
+                    case ITALIC:
+                        fontname = DEFAULT_FONT_NAME_ITALIC;
+                        break;
+                }
+                break;
+            case DEFAULT_BOLD:
+                // ignore style
+                fontname = DEFAULT_FONT_NAME_BOLD;
+                break;
+            case MONOSPACE:
+                // set Style
+                switch (this.fontStyle) {
+                    case NORMAL:
+                        fontname = "CourierNewPS-BoldMT";
+                        break;
+                    case BOLD:
+                        fontname = "CourierNewPS-BoldMT";
+                        break;
+                    case BOLD_ITALIC:
+                        fontname = "CourierNewPS-BoldMT";
+                        break;
+                    case ITALIC:
+                        fontname = "CourierNewPS-BoldMT";
+                        break;
+                }
+                break;
+            case SANS_SERIF:
+                // set Style
+                switch (this.fontStyle) {
+                    case NORMAL:
+                        fontname = "Verdana";
+                        break;
+                    case BOLD:
+                        fontname = "Verdana-Bold";
+                        break;
+                    case BOLD_ITALIC:
+                        fontname = "Verdana-BoldItalic";
+                        break;
+                    case ITALIC:
+                        fontname = "Verdana-Italic";
+                        break;
+                }
+                break;
+            case SERIF:
+                // set Style
+                switch (this.fontStyle) {
+                    case NORMAL:
+                        fontname = "Georgia";
+                        break;
+                    case BOLD:
+                        fontname = "Georgia-Bold";
+                        break;
+                    case BOLD_ITALIC:
+                        fontname = "Georgia-BoldItalic";
+                        break;
+                    case ITALIC:
+                        fontname = "Georgia-Italic";
+                        break;
+                }
+                break;
+        }
+
+        synchronized (attribs) {
+            String key = fontname + this.textSize;
+
+            //try to get buffered font
+            UIFont font = fontHashMap.get(key);
+
+            if (font == null) {
+                CTFont ctFont = CTFont.create(fontname, this.textSize, CGAffineTransform.Identity());
+
+                descent = (float) ctFont.getDescent();
+                fontHeight = (float) ctFont.getBoundingBox().getHeight();
+
+                font = ctFont.as(UIFont.class);
+                log.debug("Put Font to buffer :" + key);
+                fontHashMap.put(key, font);
+            }
+
+            CTFont ctFont = font.as(CTFont.class);
+            descent = (float) ctFont.getDescent();
+            fontHeight = (float) ctFont.getBoundingBox().getHeight();
+
+            attribs.setFont(font);
+        }
+    }
+
+
+    public void drawLine(CGBitmapContext cgBitmapContext, String text, float x, float y) {
+        if (ctLineIsDirty || !text.equals(lastText)) {
+            ctLineIsDirty = true;
+            createCTLine(text);
+        }
+        cgBitmapContext.saveGState();
+        cgBitmapContext.setShouldAntialias(true);
+        cgBitmapContext.setTextPosition(x, y + descent);
+        cgBitmapContext.setBlendMode(CGBlendMode.Overlay);
+
+        ctLine.draw(cgBitmapContext);
+
+        cgBitmapContext.restoreGState();
     }
 
     @Override
     public float getFontHeight() {
-		return IosCanvas.font.getLineHeight();
+        return fontHeight;
     }
 
     @Override
     public float getFontDescent() {
-		return IosCanvas.font.getDescent();
+        return descent;
     }
 
+    private CGLineCap getLineCap(Cap cap) {
+        switch (cap) {
+            case BUTT:
+                return CGLineCap.Butt;
+            case ROUND:
+                return CGLineCap.Round;
+            case SQUARE:
+                return CGLineCap.Square;
+        }
+        return CGLineCap.Butt;
+    }
 }