rho-tau-extensions 5.5.17

data/libs/enterprise-barcode/ext/platform/iphone/Classes/BarcodeViewFactory.h

@@ -0,0 +1,7 @@
+#include "common/RhoNativeViewManager.h"
+
+
+class BarcodeViewFactorySingletone  {
+public: 
+  static NativeViewFactory* instance();
+};

data/libs/enterprise-barcode/ext/platform/iphone/Classes/BarcodeViewFactory.mm

@@ -0,0 +1,58 @@
+
+#import <UIKit/UIKit.h>
+
+#import "BarcodeViewFactory.h"
+#import "BarcodeViewController.h"
+
+#import <strings.h>
+
+
+class BarcodeNativeView : public NativeView {
+public:
+	BarcodeNativeView() {
+		//mView = nil;
+	}
+	virtual ~BarcodeNativeView() {
+		//[mView release];
+		//mView = nil;
+	}
+	
+	virtual void* getView() {
+		//if (mView == nil) {
+		//	ctrl = []
+		//	mView = [[RainbowView alloc] init];
+		//}
+		return [BarcodeViewController getCurrentView];
+	}
+	
+	virtual void navigate(const char* url) {
+		//[mView navigate:url];
+	}
+private:
+	//MapViewControllerESRI* ctrl;
+	//UIView* mView;
+};
+
+
+
+class BarcodeNativeViewFactory : public NativeViewFactory {
+public:
+	
+	virtual NativeView* getNativeView(const char* viewType) {
+		return new BarcodeNativeView();
+	}
+	
+	virtual void destroyNativeView(NativeView* nativeView) {
+		delete nativeView;
+	}
+	
+};
+
+static BarcodeNativeViewFactory* ourFactory = NULL; 
+
+NativeViewFactory* BarcodeViewFactorySingletone::instance() {
+	if (ourFactory == NULL) {
+		ourFactory = new BarcodeNativeViewFactory();
+	}
+	return ourFactory;
+}

data/libs/enterprise-barcode/ext/platform/iphone/Classes/BarcodeViewFactoryRegister.mm

@@ -0,0 +1,18 @@
+
+// rhodes/platform/shared/common/RhoNativeViewManager.h
+#include "common/RhoNativeViewManager.h"
+
+#include "BarcodeViewFactory.h"
+
+
+	
+//extern "C" void register_Barcode_mapViewProvider();
+
+
+
+
+extern "C" void register_Barcode_View(void) {
+    NativeViewFactory* factory = BarcodeViewFactorySingletone::instance();
+    RhoNativeViewManager::registerViewType("Barcode_View", factory);
+}
+	

data/libs/enterprise-barcode/ext/platform/iphone/Classes/BarcodeViewManager.h

@@ -0,0 +1,16 @@
+
+//  Copyright 2010 __Symbol Technologies Inc.__. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@interface BarcodeViewManager : NSObject {
+
+}
+
++ (void)openView;
++ (void)closeView;
+
+@end
+

data/libs/enterprise-barcode/ext/platform/iphone/Classes/BarcodeViewManager.mm

@@ -0,0 +1,32 @@
+//
+//  RainbowSmallViewManager.m
+//  Rainbow
+//
+//  Created by Dmitry Soldatenkov on 10/15/10.
+//  Copyright 2010 __Symbol Technologies Inc.__. All rights reserved.
+//
+
+
+
+
+#import "BarcodeViewManager.h"
+#import "common/RhoNativeViewManager.h"
+
+
+
+@implementation BarcodeViewManager
+
+static int view_id = 0;
+
+
++ (void)openView {
+	view_id = RhoNativeViewManager::openNativeView("Barcode_View", OPEN_IN_MODAL_FULL_SCREEN_WINDOW, NULL);
+}
+
++ (void)closeView {
+	RhoNativeViewManager::closeNativeView(view_id);
+}
+
+
+@end
+

data/libs/enterprise-barcode/ext/platform/iphone/Classes/ImageProvider.cpp

@@ -0,0 +1,25 @@
+
+#include "ImageProvider.h"
+
+
+
+
+extern "C"
+{
+
+void rho_platform_image_load_grayscale(const char* url, void** image_pixels, int* pwidth, int* pheight) {
+	*image_pixels = 0;
+	*pwidth = 0;
+	*pheight = 0;
+	CImageProvider::rho_platform_image_load_grayscale(url, image_pixels, pwidth, pheight);
+}
+
+void rho_platform_image_free(void* image_pixels) {
+	CImageProvider::rho_platform_image_free(image_pixels);	
+}
+
+
+
+};
+
+

data/libs/enterprise-barcode/ext/platform/iphone/Classes/ImageProvider.h

@@ -0,0 +1,15 @@
+//
+//  ImageProvider.h
+//  rhorunner
+//
+//  Created by Dmitry Soldatenkov on 7/2/10.
+//  Copyright 2010 __MyCompanyName__. All rights reserved.
+//
+
+
+class CImageProvider {
+public:
+	
+	static void rho_platform_image_load_grayscale(const char* url, void** image_pixels, int* pwidth, int* pheight);
+	static void rho_platform_image_free(void* image_pixels);
+};

data/libs/enterprise-barcode/ext/platform/iphone/Classes/ImageProvider.mm

@@ -0,0 +1,159 @@
+//
+//  ImageProvider.mm
+//  rhorunner
+//
+//  Created by Dmitry Soldatenkov on 7/2/10.
+//  Copyright 2010 __MyCompanyName__. All rights reserved.
+//
+
+#import "ImageProvider.h"
+#import <UIKit/UIKit.h>
+#import <strings.h>
+
+
+class IP_Inner_Helper {
+public:
+
+static CGContextRef CreateRGBABitmapContext (CGImageRef inImage)
+{
+    CGContextRef    context = NULL;
+    CGColorSpaceRef colorSpace;
+    void *          bitmapData;
+    int             bitmapByteCount;
+    int             bitmapBytesPerRow;
+	
+	// Get image width, height. We'll use the entire image.
+    size_t pixelsWide = CGImageGetWidth(inImage);
+    size_t pixelsHigh = CGImageGetHeight(inImage);
+	
+    // Declare the number of bytes per row. Each pixel in the bitmap in this
+    // example is represented by 4 bytes; 8 bits each of red, green, blue, and
+    // alpha.
+    bitmapBytesPerRow   = (pixelsWide) << 2;
+    bitmapByteCount     = (bitmapBytesPerRow * pixelsHigh);
+	
+    // Use the generic RGB color space.
+    colorSpace = CGColorSpaceCreateDeviceRGB();//CGColorSpaceCreateDeviceGray();//(kCGColorSpaceGenericRGB);
+    if (colorSpace == NULL)
+    {
+        fprintf(stderr, "Error allocating color space\n");
+        return NULL;
+    }
+	
+    // Allocate memory for image data. This is the destination in memory
+    // where any drawing to the bitmap context will be rendered.
+    bitmapData = malloc( bitmapByteCount );
+    if (bitmapData == NULL) 
+    {
+        fprintf (stderr, "Memory not allocated!");
+        CGColorSpaceRelease( colorSpace );
+        return NULL;
+    }
+	
+    // Create the bitmap context. We want pre-multiplied ARGB, 8-bits 
+    // per component. Regardless of what the source image format is 
+    // (CMYK, Grayscale, and so on) it will be converted over to the format
+    // specified here by CGBitmapContextCreate.
+    context = CGBitmapContextCreate (bitmapData,
+									 pixelsWide,
+									 pixelsHigh,
+									 8,      // bits per component
+									 bitmapBytesPerRow,
+									 colorSpace,
+									 kCGImageAlphaNoneSkipLast);
+    if (context == NULL)
+    {
+        free (bitmapData);
+        fprintf (stderr, "Context not created!");
+    }
+	
+    // Make sure and release colorspace before returning
+    CGColorSpaceRelease( colorSpace );
+	
+    return context;
+}
+
+};
+
+
+
+
+void CImageProvider::rho_platform_image_load_grayscale(const char* url, void** image_pixels, int* pwidth, int* pheight) {
+	*image_pixels = 0;
+	*pwidth = 0;
+	*pheight = 0;
+	
+	NSString* ns_path = [NSString stringWithCString:url encoding:1];
+	UIImage* image = [UIImage imageWithContentsOfFile:ns_path];
+	CGImageRef imageRef = [image CGImage];
+    if (imageRef == NULL) 
+    { 
+        // error creating img
+        return;
+    }	
+	
+	// Create the bitmap context
+    CGContextRef cgctx = IP_Inner_Helper::CreateRGBABitmapContext(imageRef);
+    if (cgctx == NULL) 
+    { 
+        // error creating context
+        return;
+    }
+	
+	// Get image width, height. We'll use the entire image.
+    size_t w = CGImageGetWidth(imageRef);
+    size_t h = CGImageGetHeight(imageRef);
+    CGRect rect = {{0,0},{w,h}}; 
+	
+    // Draw the image to the bitmap context. Once we draw, the memory 
+    // allocated for the context for rendering will then contain the 
+    // raw image data in the specified color space.
+    CGContextDrawImage(cgctx, rect, imageRef); 
+	
+    // Now we can get a pointer to the image data associated with the bitmap
+    // context.
+    void *data = CGBitmapContextGetData (cgctx);
+    if (data != NULL)
+    {
+		
+		unsigned char* gray_buf = new unsigned char[w*h];
+		if (gray_buf != 0) {
+			*image_pixels = gray_buf;
+			*pwidth = w;
+			*pheight = h;
+		
+			// now we have image in int_32(ARGB) array
+			{
+				// make gray image
+				unsigned char* dst = gray_buf;
+				int* src = (int*)data;
+				int tk = (1<<16)/3;
+				int count = w*h;
+				int i;
+				for (i = count; i > 0; i--) {
+					int c = *src++;
+					//dst = (R+G+B)/3;
+					*dst++ = (unsigned char)((((c & 0xFF) + ((c & 0xFF00)>>8)	+ ((c & 0xFF0000)>>16))*tk)>>16);
+				}
+			}
+		}
+		
+    }
+	
+    // When finished, release the context
+    CGContextRelease(cgctx); 
+    // Free image data memory for the context
+    if (data)
+    {
+        free(data);
+    }
+	
+}
+
+void CImageProvider::rho_platform_image_free(void* image_pixels) {
+	if (image_pixels != 0) {
+	  delete image_pixels;
+	}
+}
+
+

data/libs/enterprise-barcode/ext/platform/iphone/Classes/barcode.m

@@ -0,0 +1,123 @@
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "zbar.h"
+#include "BarcodeViewController.h"
+
+#include "ruby/ext/rho/rhoruby.h"
+
+extern void rho_platform_image_load_grayscale(const char* url, void** image_pixels, int* pwidth, int* pheight);
+extern void rho_platform_image_free(void* image_pixels);
+
+extern void register_Barcode_View(void);
+
+static char strbuf[1024];
+
+void rho_barcode_take_barcode(const char* callback, VALUE options) {
+    
+    register_Barcode_View();
+    
+    [BarcodeViewController createBarcodeView:[NSString stringWithCString:callback]];
+
+}
+
+
+const char* rho_barcode_barcode_recognize(const char* filename) {
+
+   //NSLog(@"$$$$$$$$$$$$$$$$$$$$  Barcode File : %@: ", [NSString stringWithUTF8String:filename]);
+
+    void* img_buf = 0;
+    int img_width;
+    int img_height;	
+    
+  	
+    rho_platform_image_load_grayscale(filename, &img_buf, &img_width, &img_height);
+    
+    if (img_buf != 0)
+    {
+        zbar_image_scanner_t* zbar_img_scanner = zbar_image_scanner_create();
+        zbar_image_t* zbar_img = zbar_image_create();
+        const zbar_symbol_t* zbar_symbol = 0;
+        
+        zbar_image_scanner_set_config(zbar_img_scanner, ZBAR_NONE, ZBAR_CFG_ENABLE, 1);
+        
+        zbar_image_set_format(zbar_img, zbar_fourcc('Y','8','0','0'));
+        zbar_image_set_size(zbar_img, img_width, img_height);
+        //zbar_image_set_data(zbar_img, img_buf, img_width * img_height, zbar_image_free_data);
+        zbar_image_set_data(zbar_img, img_buf, img_width * img_height, 0);
+		
+        zbar_scan_image(zbar_img_scanner, zbar_img);
+        
+        
+        // get result
+        //zbar_symbol_set_t* zbar_symbols = zbar_image_get_symbols(zbar_img);
+        zbar_symbol = zbar_image_first_symbol(zbar_img);
+        
+        if (zbar_symbol != 0) {
+            //printf(zbar_symbol_get_data(zbar_symbol));
+            //sprintf(strbuf, "IMG [%d x %d ]\nCODE = %s",img_width, img_height, zbar_symbol_get_data(zbar_symbol)); 
+            strcpy(strbuf, zbar_symbol_get_data(zbar_symbol));
+        }
+        else {
+            //sprintf(strbuf, "IMG [%d x %d ]\nCODE IS UNRECOGNIZED ",img_width, img_height); 
+            strcpy(strbuf, "");
+        }
+        
+        
+        zbar_image_destroy(zbar_img);
+        zbar_image_scanner_destroy(zbar_img_scanner);
+        
+    }
+    else {
+		//sprintf(strbuf, "NO IMG TO RECOGNIZE",img_width, img_height); 
+        strcpy(strbuf, "");
+    }
+    
+    if (img_buf) {
+        rho_platform_image_free(img_buf);
+    }
+    
+    
+    return strbuf;
+}
+
+
+
+@interface RhoUIThreadCallbackRunner : NSObject {
+    
+}
+
++ (RhoUIThreadCallbackRunner*) getSharedInstance;
+
++ (void) runEnumerateCallback:(NSString*) callback_url;
+
+@end
+
+static RhoUIThreadCallbackRunner* uiThreadCallbackRunner = nil;
+
+@implementation RhoUIThreadCallbackRunner
+
++ (RhoUIThreadCallbackRunner*) getSharedInstance {
+    if (uiThreadCallbackRunner == nil) {
+        uiThreadCallbackRunner = [[RhoUIThreadCallbackRunner alloc] init];
+    }
+    return uiThreadCallbackRunner;
+}
+
+- (void) runEnumerateCallbackCommand:(NSString*) callback_url {
+    Barcode_executeEnumerateCallback(callback_url);
+}
+
+- (void) runEnumerateCallbackObj:(NSString*) callback_url {
+    [self performSelectorOnMainThread:@selector(runEnumerateCallbackCommand:) withObject:callback_url waitUntilDone:NO];
+}
+
++ (void) runEnumerateCallback:(NSString*) callback_url {
+    [[RhoUIThreadCallbackRunner getSharedInstance] runEnumerateCallbackObj:callback_url];
+}
+
+
+@end
+