rhodes 2.1.0 → 2.2.0.beta.1

data/platform/iphone/Classes/Event/Event.h

@@ -0,0 +1,12 @@
+//
+//  Event.h
+//  rhorunner
+//
+//  Created by Dmitry Moskalchuk on 16.09.10.
+//  Copyright 2010 __MyCompanyName__. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#ifdef __IPHONE_4_0
+#import <EventKit/EventKit.h>
+#endif

data/platform/iphone/Classes/Event/Event.m

@@ -0,0 +1,300 @@
+//
+//  Event.m
+//  rhorunner
+//
+//  Created by Dmitry Moskalchuk on 16.09.10.
+//  Copyright 2010 __MyCompanyName__. All rights reserved.
+//
+
+#import "Event.h"
+#import "Rhodes.h"
+
+#include "ruby.h"
+#include "ruby/ext/rho/rhoruby.h"
+#include "ruby/ext/calendar/event.h"
+
+#include "logging/RhoLogConf.h"
+#include "logging/RhoLog.h"
+
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "Event"
+
+static void calendar_check()
+{
+#if defined(__IPHONE_4_0)
+    NSString *version = [[UIDevice currentDevice] systemVersion];
+    if ([version hasPrefix:@"3."] || [version hasPrefix:@"2."])
+#endif
+        rb_raise(rb_eRuntimeError, "No calendar support on this device");
+}
+
+#ifdef __IPHONE_4_0
+static VALUE dateToRuby(NSDate *date)
+{
+    NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
+    unsigned unitFlags = NSYearCalendarUnit|NSMonthCalendarUnit|NSDayCalendarUnit;
+    NSDateComponents *dateComponents = [gregorian components:unitFlags fromDate:date];
+    unitFlags = NSHourCalendarUnit|NSMinuteCalendarUnit|NSSecondCalendarUnit;
+    NSDateComponents *timeComponents = [gregorian components:unitFlags fromDate:date];
+    
+    int year = [dateComponents year];
+    int month = [dateComponents month];
+    int day = [dateComponents day];// - 1;
+    int hour = [timeComponents hour];
+    int minute = [timeComponents minute];
+    int second = [timeComponents second];
+    
+    [gregorian release];
+    
+    VALUE rDate = rb_funcall(rb_cTime, rb_intern("utc"), 7, INT2FIX(year), INT2FIX(month), INT2FIX(day),
+                             INT2FIX(hour), INT2FIX(minute), INT2FIX(second), INT2FIX(0));
+    return rDate;
+}
+
+static NSDate *dateFromRuby(VALUE rDate)
+{
+    if (TYPE(rDate) == T_STRING) {
+        // Convert to time
+        ID id_parse = rb_intern("parse");
+        rDate = rb_funcall(rb_cTime, id_parse, 1, rDate);
+    }
+    
+    VALUE cDate = rb_class_of(rDate);
+    if (!rb_equal(cDate, rb_cTime))
+        rb_raise(rb_eArgError, "Wrong type of parameter: %s (Time expected)", rb_class2name(cDate));
+    
+    ID id_gmtime = rb_intern("gmtime");
+    ID id_year = rb_intern("year");
+    ID id_month = rb_intern("month");
+    ID id_day = rb_intern("day");
+    ID id_hour = rb_intern("hour");
+    ID id_min = rb_intern("min");
+    ID id_sec = rb_intern("sec");
+    
+    // Get GM time
+    rDate = rb_funcall(rDate, id_gmtime, 0);
+    
+    int year = FIX2INT(rb_funcall(rDate, id_year, 0));
+    int month = FIX2INT(rb_funcall(rDate, id_month, 0));
+    int day = FIX2INT(rb_funcall(rDate, id_day, 0));// + 1;
+    int hour = FIX2INT(rb_funcall(rDate, id_hour, 0));
+    int minute = FIX2INT(rb_funcall(rDate, id_min, 0));
+    int second = FIX2INT(rb_funcall(rDate, id_sec, 0));
+    
+    NSDateComponents *dateComponents = [[NSDateComponents alloc] init];
+    [dateComponents setYear:year];
+    [dateComponents setMonth:month];
+    [dateComponents setDay:day];
+    [dateComponents setHour:hour];
+    [dateComponents setMinute:minute];
+    [dateComponents setSecond:second];
+    
+    NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
+    
+    NSDate *date = [gregorian dateFromComponents:dateComponents];
+    
+    [gregorian release];
+    [dateComponents release];
+    
+    return date;
+}
+
+static VALUE eventToRuby(EKEvent *event)
+{
+    if (!event)
+        return Qnil;
+    
+    VALUE rEvent = rho_ruby_createHash();
+    const char *eid = [event.eventIdentifier UTF8String];
+    rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_ID), rb_str_new2(eid));
+    if (event.title) {
+        const char *title = [event.title UTF8String];
+        rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_TITLE), rb_str_new2(title));
+    }
+    rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_CANCELED), rho_ruby_create_boolean(event.status == EKEventStatusCanceled));
+    if (event.organizer) {
+        const char *oname = [event.organizer.name UTF8String];
+        rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_ORGANIZER), rb_str_new2(oname));
+    }
+    
+    rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_START_DATE), dateToRuby(event.startDate));
+    rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_END_DATE), dateToRuby(event.endDate));
+    rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_LAST_MODIFIED), dateToRuby(event.lastModifiedDate));
+    if (event.location) {
+        const char *location = [event.location UTF8String];
+        rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_LOCATION), rb_str_new2(location));
+    }
+    if (event.notes) {
+        const char *notes = [event.notes UTF8String];
+        rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_NOTES), rb_str_new2(notes));
+    }
+    
+    if (event.recurrenceRule) {
+        VALUE rRecurrence = rb_hash_new();
+        const char *s;
+        switch (event.recurrenceRule.frequency) {
+            case EKRecurrenceFrequencyDaily: s = RUBY_EV_RECURRENCE_FREQUENCY_DAILY; break;
+            case EKRecurrenceFrequencyWeekly: s = RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY; break;
+            case EKRecurrenceFrequencyMonthly: s = RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY; break;
+            case EKRecurrenceFrequencyYearly: s = RUBY_EV_RECURRENCE_FREQUENCY_YEARLY; break;
+            default: s = "undefined";
+        }
+        rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_FREQUENCY), rb_str_new2(s));
+        
+        int interval = event.recurrenceRule.interval;
+        rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_INTERVAL), INT2FIX(interval));
+        
+        rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_RECURRENCE), rRecurrence);
+    }
+    
+    return rEvent;
+}
+
+static EKEvent *eventFromRuby(EKEventStore *eventStore, VALUE rEvent)
+{
+    VALUE rId = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_ID));
+    if (!NIL_P(rId))
+        Check_Type(rId, T_STRING);
+    
+    EKEvent *event = nil;
+    if (NIL_P(rId) || strlen(RSTRING_PTR(rId)) == 0) {
+        // New event
+        event = [EKEvent eventWithEventStore:eventStore];
+        event.calendar = [eventStore defaultCalendarForNewEvents];
+    }
+    else {
+        // Existing event
+        const char *sid = RSTRING_PTR(rId);
+        event = [eventStore eventWithIdentifier:[NSString stringWithUTF8String:sid]];
+    }
+    
+    VALUE rTitle = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_TITLE));
+    if (!NIL_P(rTitle)) {
+        Check_Type(rTitle, T_STRING);
+        event.title = [NSString stringWithUTF8String:RSTRING_PTR(rTitle)];
+    }
+    
+    VALUE rStartDate = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_START_DATE));
+    if (!NIL_P(rStartDate))
+        event.startDate = dateFromRuby(rStartDate);
+    VALUE rEndDate = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_END_DATE));
+    if (!NIL_P(rEndDate))
+        event.endDate = dateFromRuby(rEndDate);
+    
+    VALUE rLocation = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_LOCATION));
+    if (!NIL_P(rLocation)) {
+        Check_Type(rLocation, T_STRING);
+        event.location = [NSString stringWithUTF8String:RSTRING_PTR(rLocation)];
+    }
+    
+    VALUE rNotes = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_NOTES));
+    if (!NIL_P(rNotes)) {
+        Check_Type(rNotes, T_STRING);
+        event.notes = [NSString stringWithUTF8String:RSTRING_PTR(rNotes)];
+    }
+    
+    VALUE rRecurrence = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_RECURRENCE));
+    if (!NIL_P(rRecurrence)) {
+        Check_Type(rRecurrence, T_HASH);
+        VALUE rFrequency = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_FREQUENCY));
+        Check_Type(rFrequency, T_STRING);
+        const char *frequency = RSTRING_PTR(rFrequency);
+        
+        EKRecurrenceFrequency freq;
+        if (strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_DAILY) == 0)
+            freq = EKRecurrenceFrequencyDaily;
+        else if (strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY) == 0)
+            freq = EKRecurrenceFrequencyWeekly;
+        else if (strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY) == 0)
+            freq = EKRecurrenceFrequencyMonthly;
+        else if (strcasecmp(frequency, RUBY_EV_RECURRENCE_FREQUENCY_YEARLY) == 0)
+            freq = EKRecurrenceFrequencyYearly;
+        else
+            rb_raise(rb_eArgError, "Wrong recurrence frequency: %s", frequency);
+        
+        VALUE rInterval = rb_hash_aref(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_INTERVAL));
+        rInterval = rb_funcall(rInterval, rb_intern("to_i"), 0);
+        int interval = NUM2INT(rInterval);
+        
+        EKRecurrenceRule *rule = [[EKRecurrenceRule alloc] initRecurrenceWithFrequency:freq interval:interval end:nil];
+        event.recurrenceRule = rule;
+        [rule release];
+    }
+    
+    return event;
+}
+#endif // __IPHONE_4_0
+
+VALUE event_fetch(VALUE rParams)
+{
+    calendar_check();
+    
+#if defined(__IPHONE_4_0)
+    VALUE start_date = rb_hash_aref(rParams, rb_str_new2(RUBY_EV_START_DATE));
+    VALUE end_date = rb_hash_aref(rParams, rb_str_new2(RUBY_EV_END_DATE));
+    int include_repeating = rho_ruby_get_bool(rb_hash_aref(rParams, rb_str_new2(RUBY_FETCH_include_repeating)));
+    
+    NSDate *start = dateFromRuby(start_date);
+    NSDate *finish = dateFromRuby(end_date);
+    
+    EKEventStore *eventStore = [[Rhodes sharedInstance] eventStore];
+    NSPredicate *pred = [eventStore predicateForEventsWithStartDate:start endDate:finish calendars:nil];
+    NSArray *events = [eventStore eventsMatchingPredicate:pred];
+    
+    VALUE ret = rho_ruby_create_array();
+    
+    for (int i = 0, lim = [events count]; i != lim; ++i) {
+        EKEvent *event = [events objectAtIndex:i];
+        if (!include_repeating && event.recurrenceRule)
+            continue;
+        VALUE rEvent = eventToRuby(event);
+        rho_ruby_add_to_array(ret, rEvent);
+    }
+    
+    return ret;
+#endif
+}
+
+VALUE event_fetch_by_id(const char *eid)
+{
+    calendar_check();
+    
+#if defined(__IPHONE_4_0)
+    EKEventStore *eventStore = [[Rhodes sharedInstance] eventStore];
+    EKEvent *event = [eventStore eventWithIdentifier:[NSString stringWithUTF8String:eid]];
+    
+    return eventToRuby(event);
+#endif
+}
+
+void event_save(VALUE rEvent)
+{
+    calendar_check();
+    
+#if defined(__IPHONE_4_0)
+    EKEventStore *eventStore = [[Rhodes sharedInstance] eventStore];
+
+    EKEvent *event = eventFromRuby(eventStore, rEvent);
+    
+    NSError *err;
+    BOOL saved = [eventStore saveEvent:event span:EKSpanFutureEvents error:&err];
+    
+    if (!saved)
+        rb_raise(rb_eRuntimeError, "Event save failed: %s", [[err localizedDescription] UTF8String]);
+#endif
+}
+
+void event_delete(const char *eid)
+{
+    calendar_check();
+    
+#if defined(__IPHONE_4_0)
+    EKEventStore *eventStore = [[Rhodes sharedInstance] eventStore];
+    EKEvent *event = [eventStore eventWithIdentifier:[NSString stringWithUTF8String:eid]];
+    NSError *err;
+    BOOL removed = [eventStore removeEvent:event span:EKSpanFutureEvents error:&err];
+    
+    if (!removed)
+        rb_raise(rb_eRuntimeError, "Event was not removed: %s", [[err localizedDescription] UTF8String]);
+#endif
+}

data/platform/iphone/Classes/LogOptionsController.h

@@ -8,8 +8,9 @@
 
 #import <UIKit/UIKit.h>
 #import <Foundation/Foundation.h>
+#import "RhoViewController.h"
 
-@interface LogOptionsController : UIViewController <UIScrollViewDelegate, UITextViewDelegate, UIPickerViewDelegate> {
+@interface LogOptionsController : RhoViewController <UIScrollViewDelegate, UITextViewDelegate, UIPickerViewDelegate> {
 	UITableView	*tableView;
 	UITextView *textViewEnabledCategories;
 	UITextView *textViewDisabledCategories;

data/platform/iphone/Classes/LogOptionsController.m

@@ -161,7 +161,7 @@
 	text = textViewDisabledCategories.text;
 	categories = [text cStringUsingEncoding:[NSString defaultCStringEncoding]]; 	
 	rho_logconf_setDisabledCategories(categories);
-	rho_logconf_setSeveity(selectedRow);
+	rho_logconf_setSeverity(selectedRow);
 	rho_logconf_saveSettings();
 	
 	[self dismissModalViewControllerAnimated:YES]; 

data/platform/iphone/Classes/LogViewController.h

@@ -8,8 +8,9 @@
 
 #import <UIKit/UIKit.h>
 #import <Foundation/Foundation.h>
+#import "RhoViewController.h"
 
-@interface LogViewController : UIViewController <UIScrollViewDelegate, UITextViewDelegate> {
+@interface LogViewController : RhoViewController <UIScrollViewDelegate, UITextViewDelegate> {
 	UITextView *textView;
 
 @public

data/platform/iphone/Classes/MapView/MapViewController.h

@@ -11,10 +11,11 @@
 #import <MapKit/MKAnnotation.h>
 #import <MapKit/MKReverseGeocoder.h>
 #import "GoogleGeocoder.h"
+#import "RhoViewController.h"
 
 #include "ruby/ext/rho/rhoruby.h"
 
-@interface MapViewController : UIViewController <MKReverseGeocoderDelegate,MKMapViewDelegate> {
+@interface MapViewController : RhoViewController <MKReverseGeocoderDelegate,MKMapViewDelegate> {
     MKMapView *mapView;
     MKReverseGeocoder *geoCoder;
     GoogleGeocoder* ggeoCoder;

data/platform/iphone/Classes/RhoViewController.h

@@ -0,0 +1,16 @@
+//
+//  RhoViewController.h
+//  rhorunner
+//
+//  Created by Dmitry Moskalchuk on 13.09.10.
+//  Copyright 2010 __MyCompanyName__. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+
+@interface RhoViewController : UIViewController {}
+
+- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation;
+
+@end

data/platform/iphone/Classes/RhoViewController.m

@@ -0,0 +1,20 @@
+//
+//  RhoViewController.m
+//  rhorunner
+//
+//  Created by Dmitry Moskalchuk on 13.09.10.
+//  Copyright 2010 __MyCompanyName__. All rights reserved.
+//
+
+#import "Rhodes.h"
+#import "RhoViewController.h"
+
+@implementation RhoViewController
+
+- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
+    if ([[Rhodes sharedInstance] isRotationLocked])
+        return interfaceOrientation == UIInterfaceOrientationPortrait;
+	return YES;
+}
+
+@end

data/platform/iphone/Classes/Rhodes.h

@@ -9,6 +9,9 @@
 
 #import <UIKit/UIKit.h>
 #import <AVFoundation/AVFoundation.h>
+#ifdef __IPHONE_4_0
+#import <EventKit/EventKit.h>
+#endif
 #import "AppManager.h"
 #import "RhoMainView.h"
 
@@ -34,14 +37,21 @@
     DateTimePickerDelegate* dateTimePickerDelegate;
     PickImageDelegate* pickImageDelegate;
 	SignatureDelegate* signatureDelegate;
+#ifdef __IPHONE_4_0
+    EKEventStore *eventStore;
+#endif
 	
     id<RhoMainView,NSObject> mainView;
+    BOOL rotationLocked;
 }
 
 @property (nonatomic, retain) UIWindow *window;
 @property (nonatomic, retain) AVAudioPlayer *player;
 @property (nonatomic, retain) NSMutableDictionary *cookies;
 @property (nonatomic, copy) SignatureDelegate* signatureDelegate;
+#ifdef __IPHONE_4_0
+@property (nonatomic, readonly) EKEventStore *eventStore;
+#endif
 
 + (Rhodes*)sharedInstance;
 
@@ -50,6 +60,8 @@
 + (CGRect)applicationFrame;
 + (void)setStatusBarHidden:(BOOL)v;
 
+- (BOOL)isRotationLocked;
+
 //+ (UIView*)subviewWithTag:(NSInteger)tag ofView:(UIView*)view;
 
 + (void)performOnUiThread:(id)runnable wait:(BOOL)wait;

data/platform/iphone/Classes/Rhodes.m

@@ -23,10 +23,6 @@ static BOOL app_created = NO;
 
 @implementation RhoActivateTask
 + (void)run {
-    if (!app_created) {
-        [Rhodes performOnUiThread:[RhoActivateTask class] wait:NO];
-        return;
-    }
     rho_rhodesapp_callAppActiveCallback(1);
 }
 @end
@@ -35,6 +31,9 @@ static BOOL app_created = NO;
 @implementation Rhodes
 
 @synthesize window, player, cookies, signatureDelegate;
+#ifdef __IPHONE_4_0
+@synthesize eventStore;
+#endif
 
 static Rhodes *instance = NULL;
 
@@ -130,6 +129,10 @@ static Rhodes *instance = NULL;
     [[Rhodes sharedInstance] performSelectorOnMainThread:@selector(runRunnable:) withObject:args waitUntilDone:wait];
 }
 
+- (BOOL)isRotationLocked {
+    return rotationLocked;
+}
+
 - (void)openMapLocation:(NSString*)query {
 	[self hideSplash];
     NSURL* url = [NSURL URLWithString:[@"http://maps.google.com/?" stringByAppendingString:query]];
@@ -282,7 +285,6 @@ static Rhodes *instance = NULL;
 	
 }
 
-
 - (void)choosePicture:(NSString*) url {
     if (!rho_rhodesapp_check_mode())
         return;
@@ -340,6 +342,20 @@ static Rhodes *instance = NULL;
     }
 }
 
+- (void)doRhoActivate {
+    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+    @try {
+        NSLog(@"doRhoActivate thread started");
+        while (!app_created)
+            [NSThread sleepForTimeInterval:0.1];
+        [Rhodes performOnUiThread:[RhoActivateTask class] wait:NO];
+    }
+    @finally {
+        NSLog(@"doRhoActivate thread finished");
+        [pool release];
+    }
+}
+
 - (void)doRhoInit {
     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
     @try {
@@ -355,6 +371,8 @@ static Rhodes *instance = NULL;
         rho_rhodesapp_create(szRootPath);
         app_created = YES;
         
+        rotationLocked = rho_conf_getBool("disable_screen_rotation");
+        
         NSLog(@"Show loading page");
         [self performSelectorOnMainThread:@selector(showLoadingPage) withObject:nil waitUntilDone:NO];
         
@@ -370,6 +388,7 @@ static Rhodes *instance = NULL;
     NSLog(@"Rhodes starting application...");
     instance = self;
     application = [UIApplication sharedApplication];
+    rotationLocked = YES;
     
     [NSThread setThreadPriority:1.0];
     
@@ -409,6 +428,10 @@ static Rhodes *instance = NULL;
     [[UIApplication sharedApplication] registerForRemoteNotificationTypes:
      (UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeSound)];
 #endif
+    
+#ifdef __IPHONE_4_0
+    eventStore = [[EKEventStore alloc] init];
+#endif
 
     NSLog(@"Initialization finished");
 }
@@ -611,7 +634,12 @@ static Rhodes *instance = NULL;
 
 - (void)applicationDidBecomeActive:(UIApplication *)application {
     RAWLOG_INFO("Application did become active");
-    [Rhodes performOnUiThread:[RhoActivateTask class] wait:NO];
+    if (!app_created) {
+        NSLog(@"Application is not created yet so postpone activation callback");
+        [NSThread detachNewThreadSelector:@selector(doRhoActivate) toTarget:self withObject:nil];
+    }
+    else
+        [Rhodes performOnUiThread:[RhoActivateTask class] wait:NO];
 }
 
 - (void)applicationWillResignActive:(UIApplication *)application {