rhodes 2.1.0 → 2.2.0.beta.1

data/platform/wm/rhodes/phonebook/NativeAddressBook.h

@@ -96,12 +96,8 @@ public:
 
 protected:
 	//outlook
-	bool m_openedOutlookAB;
-	IPOutlookApp* m_outlookApp;
 	IPOutlookItemCollection* m_outlookItems;
 
-	int initOutlookAB();
-	int closeOutlookAB();
 	bool getOutlookItems();
 	int getAllOutlookRecords(std::vector<CABRecord*>& records);
 	CABRecord* getOutlookRecord(long oid);

data/platform/wm/rhodes/resource.h

@@ -17,8 +17,10 @@
 #define IDD_SIMULATOR_LOGOPTIONS        116
 #define IDI_ICON                        117
 #define IDD_DATETIME_PICKER             118
-//#define IDD_DATEPICKER                  119
 #define IDD_TIME_PICKER                 119
+#define IDD_BLUETOOTH_DISCOVER          120
+#define IDR_BLUETOOTH_DISCOVER          120
+#define IDD_BLUETOOTH_DISCOVERED        121
 #define IDC_STATIC_PROMPT               1001
 #define IDC_EDIT_URL                    1002
 #define IDC_LOGEDIT                     1003
@@ -33,11 +35,16 @@
 #define IDC_TIME_CTRL                   1013
 #define IDC_DATE_STATIC                 1017
 #define IDC_TIME_STATIC                 1019
+#define IDC_BT_LIST                     1020
+#define IDC_BUTTON1                     1022
+#define IDC_BT_CANCEL                   1022
+#define IDC_BT_STATIC                   1023
 #define IDS_EXIT                        10001
 #define IDS_MENU                        10002
 #define IDS_OK                          10003
 #define IDS_CANCEL                      10004
 #define IDS_WND_CLASS                   10005
+#define IDS_CONNECT                     10006
 #define IDM_SK1_EXIT                    40001
 #define IDM_SK2_MENU                    40002
 #define IDM_BACK                        40003

data/platform/wm/rhodes/rho/net/NetRequest.cpp

@@ -32,6 +32,7 @@ INetResponse* CNetRequest::pullCookies(const String& strUrl, const String& strBo
 
 INetResponse* CNetRequest::doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders )
 {
+    m_bCancel = false;
     CNetRequestImpl oImpl(this, method,strUrl,oSession,pHeaders, m_sslVerifyPeer);
     return oImpl.sendString(strBody);
 }
@@ -51,6 +52,7 @@ void CNetRequest::cancel()
 
 INetResponse* CNetRequest::pushMultipartData(const String& strUrl, VectorPtr<CMultipartItem*>& arItems, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
 {
+    m_bCancel = false;
     CNetRequestImpl oImpl(this, "POST",strUrl,oSession,pHeaders,m_sslVerifyPeer);
     CNetResponseImpl* pResp = oImpl.sendMultipartData(arItems);
     return pResp;
@@ -58,6 +60,7 @@ INetResponse* CNetRequest::pushMultipartData(const String& strUrl, VectorPtr<CMu
 
 INetResponse* CNetRequest::pushMultipartData(const String& strUrl, CMultipartItem& oItem, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
 {
+    m_bCancel = false;
     VectorPtr<CMultipartItem*> arItems;
     arItems.addElement(&oItem);
 
@@ -69,6 +72,7 @@ INetResponse* CNetRequest::pushMultipartData(const String& strUrl, CMultipartIte
 
 INetResponse* CNetRequest::pullFile(const String& strUrl, const String& strFilePath, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
 {
+    m_bCancel = false;
     common::CRhoFile oFile;
     if ( !oFile.open(strFilePath.c_str(),common::CRhoFile::OpenForAppend) ) 
     {

data/platform/wm/rhodes/rho/net/NetRequestImpl.cpp

@@ -411,11 +411,13 @@ CNetResponseImpl* CNetRequestImpl::downloadFile(common::CRhoFile& oFile)
             break;
         }
 
-        if (!pDownloadBuffer)
-            pDownloadBuffer = new char[nDownloadBufferSize];
-
-        readInetFile(m_hRequest,pNetResp, &oFile, pDownloadBuffer, nDownloadBufferSize);
+        if ( pNetResp->isOK() )
+        {
+            if (!pDownloadBuffer)
+                pDownloadBuffer = new char[nDownloadBufferSize];
 
+            readInetFile(m_hRequest,pNetResp, &oFile, pDownloadBuffer, nDownloadBufferSize);
+        }
     }while(0);
 
     if (pDownloadBuffer)

data/platform/wm/rhodes/rho/rubyext/calendar.cpp

@@ -0,0 +1,487 @@
+#include "stdafx.h"
+
+#include "ruby/ext/rho/rhoruby.h"
+#if defined(OS_WINCE)
+#include "ruby/ext/calendar/event.h"
+#include "OutlookApp.h"
+#include "common/StringConverter.h"
+#include "Utils.h"
+
+#include "logging/RhoLogConf.h"
+#include "logging/RhoLog.h"
+
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "Event"
+
+#ifdef _WIN32_WCE
+#define INITGUID
+#include <pimstore.h>
+#endif //_WIN32_WCE
+
+using namespace rho;
+using namespace rho::common;
+
+static void calendar_check()
+{
+    COutlookApp::Create();
+    if ( !COutlookApp::getInstance()->getApp() )
+    {
+        rho_ruby_raise_runtime("No calendar support on this device");
+    }
+}
+
+int checkHResult(HRESULT res, const char* file, int line, const char* msg )
+{
+    if (FAILED(res))
+    {
+        LOG(ERROR) + "Method: " + msg + ";Line: " + line; 
+        rho_ruby_raise_runtime("Calendar method failed.");
+        return 0;
+    }
+
+    return 1;
+}
+
+#define START_CHECK while(1){
+#define CHECK(res) {if(!checkHResult(res, __FILE__, __LINE__, #res )) break;}
+#define END_CHECK break; }
+
+static void addVariantTimeToHash(VALUE hash, const char* key, DATE time)
+{
+    SYSTEMTIME sysTime = {0};
+    VariantTimeToSystemTime(time, &sysTime);
+
+    addTimeToHash(hash, key, SystemTimeToUnixTime(&sysTime));
+}
+
+static DATE dateFromRuby(VALUE rDate)
+{
+    SYSTEMTIME sysTime = {0};
+    UnixTimeToSystemTime(rho_ruby_get_time(rDate), &sysTime );
+
+    DATE time = 0;
+    SystemTimeToVariantTime(&sysTime, &time);
+
+    return time;
+}
+
+static VALUE eventToRuby(IAppointment *pEvent)
+{
+    if (!pEvent)
+        return rho_ruby_get_NIL();
+    
+    VALUE rEvent = rho_ruby_createHash();
+
+    long lOid = 0;
+    if ( SUCCEEDED(pEvent->get_Oid(&lOid)) ) 
+        addStrToHash(rEvent, RUBY_EV_ID, convertToStringA(lOid).c_str() );
+
+    CComBSTR bstrSubj;
+    if ( SUCCEEDED(pEvent->get_Subject(&bstrSubj)) ) 
+        addStrToHash(rEvent, RUBY_EV_TITLE, convertToStringA((BSTR)bstrSubj).c_str() );
+
+    long lStatus = 0;
+    if ( SUCCEEDED(pEvent->get_MeetingStatus(&lStatus)) ) 
+        addBoolToHash(rEvent, RUBY_EV_CANCELED, lStatus==olMeetingCanceled ? 1:0);
+
+    long lSensitivity = 0;
+    if ( SUCCEEDED(pEvent->get_Sensitivity(&lSensitivity)) ) 
+    {
+        String strPrivacy = "public";
+        switch(lSensitivity)
+        {
+        case olPersonal:
+            strPrivacy = "personal";
+            break;
+        case olPrivate:
+            strPrivacy = "private";
+            break;
+        case olConfidential:
+            strPrivacy = "confidential";
+            break;
+        }
+
+        addStrToHash(rEvent, RUBY_EV_PRIVACY, strPrivacy.c_str());
+    }
+
+    CComBSTR bstrLoc;
+    if ( SUCCEEDED(pEvent->get_Location(&bstrLoc)) ) 
+        addStrToHash(rEvent, RUBY_EV_LOCATION, convertToStringA((BSTR)bstrLoc).c_str() );
+
+    CComBSTR bstrNotes;
+    if ( SUCCEEDED(pEvent->get_Body(&bstrNotes)) ) 
+        addStrToHash(rEvent, RUBY_EV_NOTES, convertToStringA((BSTR)bstrNotes).c_str() );
+
+    DATE dStart = 0;
+    if ( SUCCEEDED(pEvent->get_Start(&dStart)) )
+        addVariantTimeToHash(rEvent, RUBY_EV_START_DATE, dStart);
+
+    DATE dEnd = 0;
+    if ( SUCCEEDED(pEvent->get_End(&dEnd)) )
+        addVariantTimeToHash(rEvent, RUBY_EV_END_DATE, dEnd);
+
+    VARIANT_BOOL bReminder;
+    if ( SUCCEEDED(pEvent->get_ReminderSet(&bReminder)) && bReminder == VARIANT_TRUE)
+    {
+        long lMinutes = 0;
+        if ( SUCCEEDED(pEvent->get_ReminderMinutesBeforeStart(&lMinutes)) ) 
+            addIntToHash(rEvent, RUBY_EV_REMINDER, (int)lMinutes);
+    }
+
+    VARIANT_BOOL bIsRecurring;
+    CComPtr<IRecurrencePattern> pRP;
+    if ( SUCCEEDED(pEvent->get_IsRecurring(&bIsRecurring)) && bIsRecurring == VARIANT_TRUE &&
+         SUCCEEDED(pEvent->GetRecurrencePattern(&pRP)) && pRP )
+    {
+        long lRecType = 0;
+        if ( SUCCEEDED(pEvent->get_IsRecurring(&bIsRecurring)) && bIsRecurring == VARIANT_TRUE &&
+             SUCCEEDED(pRP->get_RecurrenceType(&lRecType)) && lRecType != olRecursOnce ) 
+        {
+            VALUE rRecur = rho_ruby_createHash();        
+
+            switch( lRecType )
+            {
+            case olRecursDaily:
+                addStrToHash(rRecur, RUBY_EV_RECURRENCE_FREQUENCY, RUBY_EV_RECURRENCE_FREQUENCY_DAILY );
+                break;
+            case olRecursWeekly:
+                addStrToHash(rRecur, RUBY_EV_RECURRENCE_FREQUENCY, RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY );
+                break;
+            case olRecursMonthly:
+            case olRecursMonthNth:
+                addStrToHash(rRecur, RUBY_EV_RECURRENCE_FREQUENCY, RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY );
+                break;
+            case olRecursYearly:
+            case olRecursYearNth:
+                addStrToHash(rRecur, RUBY_EV_RECURRENCE_FREQUENCY, RUBY_EV_RECURRENCE_FREQUENCY_YEARLY );
+                break;
+            }
+
+            long lInterval = 0;
+            if ( SUCCEEDED(pRP->get_Interval(&lInterval)) ) 
+                addIntToHash(rRecur, RUBY_EV_RECURRENCE_INTERVAL, (int)lInterval);
+            long lOccurrences = 0;
+            VARIANT_BOOL bNoEndDate;
+            if ( SUCCEEDED(pRP->get_NoEndDate(&bNoEndDate)) && bNoEndDate == VARIANT_FALSE &&
+                 SUCCEEDED(pRP->get_Occurrences(&lOccurrences)) ) 
+                addIntToHash(rRecur, RUBY_EV_RECURRENCE_COUNT, (int)lOccurrences);
+
+            DATE dEnd = 0;
+            if ( SUCCEEDED(pRP->get_EndTime(&dEnd)) )
+                addVariantTimeToHash(rEvent, RUBY_EV_RECURRENCE_END, dEnd);
+
+            long lDayOfMonth = 0;
+            if ( SUCCEEDED(pRP->get_DayOfMonth(&lDayOfMonth)) ) 
+                addIntToHash(rRecur, RUBY_EV_RECURRENCE_DAYOFMONTH, (int)lDayOfMonth);
+
+            long lMonthOfYear = 0;
+            if ( SUCCEEDED(pRP->get_MonthOfYear(&lMonthOfYear)) ) 
+            {
+                VALUE arMonths = rho_ruby_create_array();
+                for ( int i = 1; i <= 12; i++ )
+                    rho_ruby_add_to_array(arMonths, rho_ruby_create_integer(i == lMonthOfYear ? 1:0) );
+
+                addHashToHash(rRecur, RUBY_EV_RECURRENCE_MONTHS, arMonths);
+            }
+
+            long lDayOfWeekMask = 0;
+            if ( SUCCEEDED(pRP->get_DayOfWeekMask(&lDayOfWeekMask)) ) 
+            {
+                VALUE arDays = rho_ruby_create_array();
+                rho_ruby_add_to_array(arDays, rho_ruby_create_integer( (lDayOfWeekMask&olMonday)!= 0 ? 1:0) );
+                rho_ruby_add_to_array(arDays, rho_ruby_create_integer( (lDayOfWeekMask&olTuesday)!= 0 ? 1:0) );
+                rho_ruby_add_to_array(arDays, rho_ruby_create_integer( (lDayOfWeekMask&olWednesday)!= 0 ? 1:0) );
+                rho_ruby_add_to_array(arDays, rho_ruby_create_integer( (lDayOfWeekMask&olThursday)!= 0 ? 1:0) );
+                rho_ruby_add_to_array(arDays, rho_ruby_create_integer( (lDayOfWeekMask&olFriday)!= 0 ? 1:0) );
+                rho_ruby_add_to_array(arDays, rho_ruby_create_integer( (lDayOfWeekMask&olSaturday)!= 0 ? 1:0) );
+                rho_ruby_add_to_array(arDays, rho_ruby_create_integer( (lDayOfWeekMask&olSunday)!= 0 ? 1:0) );
+
+                addHashToHash(rRecur, RUBY_EV_RECURRENCE_DAYS, arDays);
+            }
+
+            addHashToHash(rEvent, RUBY_EV_RECURRENCE, rRecur);
+        }
+    }
+
+    return rEvent;
+}
+
+static void eventFromRuby(VALUE rEvent, IAppointment* pEvent)
+{
+    //VALUE rId = rb_hash_aref(rEvent, rb_str_new2(RUBY_EV_ID));
+    //if (!NIL_P(rId))
+    //    Check_Type(rId, T_STRING);
+    START_CHECK
+
+    VALUE rTitle = rho_ruby_hash_aref(rEvent, RUBY_EV_TITLE);
+    if (!rho_ruby_is_NIL(rTitle)) 
+        CHECK( pEvent->put_Subject(const_cast<BSTR>(convertToStringW( String(getStringFromValue(rTitle))).c_str())) );
+
+    VALUE rCancelled = rho_ruby_hash_aref(rEvent, RUBY_EV_CANCELED);
+    if (!rho_ruby_is_NIL(rCancelled)) 
+    {
+        if( rho_ruby_get_bool(rCancelled) )
+            CHECK( pEvent->Cancel() );
+    }
+
+    VALUE rPrivacy = rho_ruby_hash_aref(rEvent, RUBY_EV_PRIVACY);
+    if (!rho_ruby_is_NIL(rPrivacy)) 
+    {
+        String strPrivacy = getStringFromValue(rPrivacy);
+        long lSensitivity = olNormal;
+        if ( strPrivacy.compare("personal") == 0 )
+            lSensitivity = olPersonal;
+        else if ( strPrivacy.compare("private") == 0 )
+            lSensitivity = olPrivate;
+        else if ( strPrivacy.compare("confidential") == 0 )
+            lSensitivity = olConfidential;
+
+        CHECK( pEvent->put_Sensitivity(lSensitivity) );
+    }
+
+    VALUE rLoc = rho_ruby_hash_aref(rEvent, RUBY_EV_LOCATION);
+    if (!rho_ruby_is_NIL(rLoc)) 
+        CHECK( pEvent->put_Location(const_cast<BSTR>(convertToStringW( String(getStringFromValue(rLoc))).c_str())) );
+
+    VALUE rNotes = rho_ruby_hash_aref(rEvent, RUBY_EV_NOTES);
+    if (!rho_ruby_is_NIL(rNotes)) 
+        CHECK( pEvent->put_Body(const_cast<BSTR>(convertToStringW( String(getStringFromValue(rNotes))).c_str())));
+
+    VALUE rStartDate = rho_ruby_hash_aref(rEvent, RUBY_EV_START_DATE);
+    if (!rho_ruby_is_NIL(rStartDate))
+        CHECK( pEvent->put_Start(dateFromRuby(rStartDate)));
+
+    VALUE rEndDate = rho_ruby_hash_aref(rEvent, RUBY_EV_END_DATE);
+    if (!rho_ruby_is_NIL(rEndDate))
+        CHECK( pEvent->put_End(dateFromRuby(rEndDate)) );
+
+    VALUE rReminder = rho_ruby_hash_aref(rEvent, RUBY_EV_REMINDER);
+    if (!rho_ruby_is_NIL(rReminder))
+    {
+        CHECK( pEvent->put_ReminderSet(VARIANT_TRUE) );
+        CHECK( pEvent->put_ReminderMinutesBeforeStart(rho_ruby_get_int(rReminder)) );
+    }
+
+    VALUE rRecur = rho_ruby_hash_aref(rEvent, RUBY_EV_RECURRENCE);
+    if (!rho_ruby_is_NIL(rRecur))
+    {
+        CHECK( pEvent->ClearRecurrencePattern() );
+        CComPtr<IRecurrencePattern> pRP;
+        if ( SUCCEEDED(pEvent->GetRecurrencePattern(&pRP)) && pRP )
+        {
+            VALUE rFreq = rho_ruby_hash_aref(rRecur, RUBY_EV_RECURRENCE_FREQUENCY);
+            if (!rho_ruby_is_NIL(rFreq))
+            {
+                long lRecType = 0;
+                String strFreq = getStringFromValue(rFreq);
+                if ( strFreq.compare(RUBY_EV_RECURRENCE_FREQUENCY_DAILY) == 0 )
+                    lRecType = olRecursDaily;
+                else if ( strFreq.compare(RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY) == 0 )
+                    lRecType = olRecursWeekly;
+                else if ( strFreq.compare(RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY) == 0 )
+                    lRecType = olRecursMonthly;
+                else if ( strFreq.compare(RUBY_EV_RECURRENCE_FREQUENCY_YEARLY) == 0 )
+                    lRecType = olRecursYearly;
+
+                CHECK( pRP->put_RecurrenceType(lRecType) );
+            }
+
+            VALUE rInterval = rho_ruby_hash_aref(rRecur, RUBY_EV_RECURRENCE_INTERVAL);
+            if (!rho_ruby_is_NIL(rInterval))
+                CHECK( pRP->put_Interval(rho_ruby_get_int(rInterval)) );
+
+            VALUE rOccurrences = rho_ruby_hash_aref(rRecur, RUBY_EV_RECURRENCE_COUNT);
+            if (!rho_ruby_is_NIL(rOccurrences))
+            {
+                CHECK( pRP->put_NoEndDate(VARIANT_FALSE) );
+                CHECK( pRP->put_Occurrences(rho_ruby_get_int(rOccurrences)) );
+            }
+
+            VALUE rEnd = rho_ruby_hash_aref(rRecur, RUBY_EV_RECURRENCE_END);
+            if (!rho_ruby_is_NIL(rEnd))
+                CHECK( pRP->put_EndTime(dateFromRuby(rEnd)) );
+
+            VALUE rDayOfMonth = rho_ruby_hash_aref(rRecur, RUBY_EV_RECURRENCE_DAYOFMONTH);
+            if (!rho_ruby_is_NIL(rDayOfMonth))
+                CHECK( pRP->put_DayOfMonth(rho_ruby_get_int(rDayOfMonth)) );
+
+            VALUE rMonthOfYear = rho_ruby_hash_aref(rRecur, RUBY_EV_RECURRENCE_MONTHS);
+            if (!rho_ruby_is_NIL(rMonthOfYear))
+            {
+                for ( int i = 1; i <= 12; i++ )
+                {
+                    VALUE val = rho_ruby_array_get(rMonthOfYear, i-1);
+                    if ( rho_ruby_get_int(val) != 0)
+                    {
+                        CHECK( pRP->put_MonthOfYear(i) );
+                        break;
+                    }
+                }
+            }
+
+            VALUE rDayOfWeek = rho_ruby_hash_aref(rRecur, RUBY_EV_RECURRENCE_DAYS);
+            if (!rho_ruby_is_NIL(rDayOfWeek))
+            {
+                long lDayOfWeekMask = 0;
+
+                if ( rho_ruby_get_int( rho_ruby_array_get(rDayOfWeek, 0) ) )
+                    lDayOfWeekMask |= olMonday;
+                if ( rho_ruby_get_int( rho_ruby_array_get(rDayOfWeek, 1) ) )
+                    lDayOfWeekMask |= olTuesday;
+                if ( rho_ruby_get_int( rho_ruby_array_get(rDayOfWeek, 2) ) )
+                    lDayOfWeekMask |= olWednesday;
+                if ( rho_ruby_get_int( rho_ruby_array_get(rDayOfWeek, 3) ) )
+                    lDayOfWeekMask |= olThursday;
+                if ( rho_ruby_get_int( rho_ruby_array_get(rDayOfWeek, 4) ) )
+                    lDayOfWeekMask |= olFriday;
+                if ( rho_ruby_get_int( rho_ruby_array_get(rDayOfWeek, 5) ) )
+                    lDayOfWeekMask |= olSaturday;
+                if ( rho_ruby_get_int( rho_ruby_array_get(rDayOfWeek, 6) ) )
+                    lDayOfWeekMask |= olSunday;
+
+                CHECK( pRP->put_DayOfWeekMask(lDayOfWeekMask) );
+            }
+        }
+    }
+    END_CHECK
+
+}
+
+extern "C" VALUE event_fetch(VALUE params)
+{
+    calendar_check();
+    IPOutlookApp * polApp = COutlookApp::getInstance()->getApp();
+
+    CComPtr<IPOutlookItemCollection> pItems;
+    CComPtr<IFolder>                 pFolder;
+
+    VALUE start_date = rho_ruby_hash_aref(params,RUBY_EV_START_DATE);
+    VALUE end_date = rho_ruby_hash_aref(params,RUBY_EV_END_DATE);
+    VALUE include_repeating = rho_ruby_hash_aref(params,RUBY_FETCH_include_repeating);
+    VALUE ret = rho_ruby_create_array();
+
+    START_CHECK
+        CHECK( polApp->GetDefaultFolder(olFolderCalendar, &pFolder) );
+
+        CHECK( pFolder->get_Items(&pItems) );
+
+        if (rho_ruby_get_bool(include_repeating))
+            CHECK( pItems->put_IncludeRecurrences(VARIANT_TRUE) );
+
+        DATE dStart = dateFromRuby(start_date);
+        DATE dEnd = dateFromRuby(end_date);
+        WCHAR szRestrict[250];
+        StringCchPrintf(szRestrict, ARRAYSIZE(szRestrict), TEXT("[Start] >= <%f AND [End] <= <%f"), dStart, dEnd);
+        bool bFirst = true;
+        while(true)
+        {
+            CComPtr<IAppointment>            pEvent;
+            if ( bFirst )
+                pItems->Find(szRestrict, (IDispatch **)&pEvent);
+            else
+                pItems->FindNext((IDispatch **)&pEvent);
+
+            if (!pEvent)
+                break;
+
+            VALUE rEvent = eventToRuby(pEvent);
+            rho_ruby_add_to_array(ret, rEvent);
+
+            bFirst = false;
+        }
+    END_CHECK
+
+    return ret;
+}
+
+IAppointment* findEventById(IPOutlookApp * polApp, const char *eid)
+{
+    if ( !eid || !*eid )
+        return 0;
+
+    CComPtr<IPOutlookItemCollection> pItems;
+    CComPtr<IFolder>                 pFolder;
+
+    START_CHECK
+
+        CHECK( polApp->GetDefaultFolder(olFolderCalendar, &pFolder) );
+        CHECK( pFolder->get_Items(&pItems) );
+
+        String strCond = String("[Oid] = ") + eid;
+        IAppointment*            pEvent;
+        CHECK( pItems->Find( const_cast<BSTR>(convertToStringW(strCond).c_str()), (IDispatch**)&pEvent) );
+
+        return pEvent;
+
+    END_CHECK
+
+    return 0;
+}
+
+extern "C" VALUE event_fetch_by_id(const char *eid)
+{
+    calendar_check();
+    IPOutlookApp * polApp = COutlookApp::getInstance()->getApp();
+
+    CComPtr<IAppointment>  pEvent = findEventById(polApp, eid);
+    if ( pEvent )
+        return eventToRuby(pEvent);
+
+    return rho_ruby_get_NIL();
+}
+
+extern "C" void event_save(VALUE rEvent)
+{
+    calendar_check();
+    IPOutlookApp * polApp = COutlookApp::getInstance()->getApp();
+
+    START_CHECK
+        CComPtr<IAppointment> pEvent;
+        VALUE rId = rho_ruby_hash_aref(rEvent, RUBY_EV_ID);
+        if (!rho_ruby_is_NIL(rId))
+            pEvent = findEventById(polApp, getStringFromValue(rId));
+
+        if ( !pEvent )
+            CHECK(polApp->CreateItem(olAppointmentItem, (IDispatch**)&pEvent));
+
+        eventFromRuby(rEvent, pEvent);
+
+        CHECK(pEvent->Save());
+    END_CHECK
+}
+
+extern "C" void event_delete(const char *eid)
+{
+    calendar_check();
+    IPOutlookApp * polApp = COutlookApp::getInstance()->getApp();
+
+    START_CHECK
+
+        CComPtr<IAppointment>  pEvent = findEventById(polApp, eid);
+        if ( pEvent )
+            CHECK(pEvent->Delete());
+
+    END_CHECK
+
+}
+#else //!OS_WINCE
+
+extern "C" VALUE event_fetch(VALUE start_date, VALUE end_date)
+{
+    return  rho_ruby_create_array();
+}
+
+extern "C" VALUE event_fetch_by_id(const char *eid)
+{
+    return  rho_ruby_get_NIL();
+}
+
+extern "C" void event_save(VALUE rEvent)
+{
+}
+
+extern "C" void event_delete(const char *eid)
+{
+}
+
+#endif