calendarmodule.cpp

python s60 1.4.5版本的源代码

/*
 * ====================================================================
 *  calendarmodule.h
 *
 *  Python API to Series 60 Calendar database.
 *
 * Copyright (c) 2006-2008 Nokia Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ====================================================================
 */

  
#include "calendarmodule.h"
#include <e32const.h>


//////////////GENERAL FUNCTIONS///////////////

/*
 * Converts python time to UTC TTime value
 */
void pythonRealUtcAsTTime(TReal timeValue, TTime& theTime)
{
  TInt64 timeInt((timeValue*1000.0*1000.0)+epoch_as_TReal());
  theTime = timeInt;
}

/*
 * Returns date value that corresponds the given datetime value.
 */
TTime truncToDate(const TTime& theTime)
{
  TTime temp = theTime;
  
  // ??? check the summer to winter conversion and double local time.
  RTz tz;
  tz.Connect();
  tz.ConvertToLocalTime(temp);
  TDateTime aDateTime = temp.DateTime();
  aDateTime.SetHour(0); 
  aDateTime.SetMinute(0); 
  aDateTime.SetSecond(0); 
  temp = aDateTime;
  tz.Close();
  return temp;
}


/*
 * Checks if the time value is in the limits of native calendar API (and not null).
 */
TBool Check_time_validity(const TTime& theTime)
{
  if(theTime<=TCalTime::MinTime() ||
     TCalTime::MaxTime()<theTime){
    return EFalse; // Illegal time value.
  }else{
    return ETrue;
  }
}

/*
 * Give the next month of given month
 */
TMonth getNextMonth(TMonth aMonth){

switch(aMonth){
  case EJanuary:
    return EFebruary;
  case EFebruary:
    return EMarch;
  case EMarch:
    return EApril;
  case EApril:
    return EMay;
  case EMay:
    return EJune;
  case EJune:
    return EJuly;
  case EJuly:
    return EAugust;
  case EAugust:
    return ESeptember;
  case ESeptember:
    return EOctober;
  case EOctober:
    return ENovember;
  case ENovember:
    return EDecember;
  case EDecember:
    return EJanuary;
  }
  return aMonth;
}

/*
 * Checks if the value represents a weekday.
 */
TBool isWeekday(TInt value)
{
  TBool retVal = ETrue;
  switch(value){
    case EMonday:
    break;
    case ETuesday:
    break;
    case EWednesday:
    break; 
    case EThursday:
    break;
    case EFriday:
    break;
    case ESaturday:
    break;
    case ESunday:
    break;
    default:
      retVal = EFalse;
    break;
  }
  return retVal;
}


/*
 * Checks if the value represents a month.
 */
TBool isMonth(TInt value)
{
  TBool retVal = ETrue;
  switch(value){
    case EJanuary:
    break;
    case EFebruary:
    break;
    case EMarch:
    break;
    case EApril:
    break;
    case EMay:
    break;
    case EJune:
    break;
    case EJuly:
    break;
    case EAugust:
    break;
    case ESeptember:
    break;
    case EOctober:
    break;
    case ENovember:
    break;
    case EDecember:
    break;
    default:
      retVal = EFalse;
    break;
  }
  return retVal;
}


/*
 * Checks if the value represents a weeknumber (in month).
 */
TBool isWeekInMonth(TInt value)
{
  TBool retVal = ETrue;
  switch(value){
    case 0:
    break;
    case 1:
    break;
    case 2:
    break;
    case 3:
    break;
    case 4:
    break;
    default:
      retVal = EFalse;
    break;
  }
  return retVal;
}


/* Workaround for a platform bug that StartTimeL() raises exception
 * with return code -6 (KErrArgument) , when aCallTime is set to null time.
 * In case of the KErrArgument exception, aCallTime will be set to 
 * TCalTime::MinTime(). This workarround would cause problem if the 
 * exception KErrArgument is raised because of some other reason then previously 
 * mentioned platform bug.
 */ 
TInt GetStartTime(CCalEntry& aEntry,TTime& aStartTime)
{
  TInt error = KErrNone;
  TRAP(error, {
    aStartTime = aEntry.StartTimeL().TimeLocalL();
  });
  if(error == KErrArgument){
    aStartTime = TCalTime::MinTime();
    return (KErrNone);
  }
  return error;
}

TInt GetEndTime(CCalEntry& aEntry,TTime& aEndTime)
{
  TInt error = KErrNone;
  TRAP(error, {
    aEndTime = aEntry.EndTimeL().TimeLocalL();
  });
  if(error == KErrArgument){
    aEndTime = TCalTime::MinTime();
    return (KErrNone);
  }
  return error;
}

TInt GetInstanceStartTime(CCalInstance* aInstance,TTime& aStartTime)
{
  TInt error = KErrNone;
  TRAP(error, {
    aStartTime = aInstance->StartTimeL().TimeLocalL();
  });
  if(error == KErrArgument){
    aStartTime = TCalTime::MinTime();
    return (KErrNone);
  }
  return error;
}

TInt GetInstanceEndTime(CCalInstance& aInstance,TTime& aEndTime)
{
  TInt error = KErrNone;
  TRAP(error, {
    aEndTime = aInstance.EndTimeL().TimeLocalL();
  });
  if(error == KErrArgument){
    aEndTime = TCalTime::MinTime();
    return (KErrNone);
  }
  return error;
}

/*
 * CalendarDb methods.
 */

 

/*
 * Create new CalendarDb object.
 */
extern "C" PyObject *
new_CalendarDb_object(CCalSession* session, CCalEntryViewAdapter* entryViewAdapter)
{ 
  CalendarDb_object* calendarDb = 
    PyObject_New(CalendarDb_object, CalendarDb_type);
  if (calendarDb == NULL){
    delete entryViewAdapter;
    delete session;
    return PyErr_NoMemory();
  }
 
  calendarDb->session = session;
  calendarDb->entryViewAdapter = entryViewAdapter;
  calendarDb->instanceViewAdapter = NULL; // this is instantiated only if needed.
  
  return (PyObject*)calendarDb;
}


/*
 * This was implemented because there were crashes when using
 * CCalSession::OpenL (if the file did not exist).
 */
TInt isExistingFileL(CCalSession& session, const TDesC& filename)
{
  TInt pos = -1;
  CDesCArray* arr = session.ListCalFilesL();

  if(arr==NULL){
    return -1;
  }

  if(0 == arr->Find(filename,pos)){
    delete arr;
    return pos;
  };
  
  delete arr;
  return -1;
}

 
/*
 * Opens the database and creates and returns a CalendarDb-object.
 *
 * open() - opens the default agenda database file
 * open(u'<drive>:filename') - opens file if it exists.
 * open(u'<drive>:filename', 'c') - opens file, creates if the file does not exist.
 * open(u'<drive>:filename', 'n') - creates new empty database file (overwrites the existing one).
 */
extern "C" PyObject *
open_db(PyObject* /*self*/, PyObject *args)
{  
  PyObject* filename = NULL;
  char* flag = NULL;
  CCalSession* session = NULL;
  CCalEntryViewAdapter* entryViewAdapter = NULL;
  TInt err = KErrNone;
  TInt progressError = KErrNone;

  if (!PyArg_ParseTuple(args, "|Us", &filename, &flag)){ 
    return NULL;
  }
    
  // Open or create new agenda file.
  TRAP(err, session = CCalSession::NewL());
  if(err != KErrNone){
    return SPyErr_SetFromSymbianOSErr(err);
  }
  if(!flag){
    if(!filename){
      TRAP(err, {
        TInt fileExists = -1;        
        fileExists = isExistingFileL(*session,session->DefaultFileNameL());
        if(0<=fileExists){
          session->OpenL(session->DefaultFileNameL());
        }else{
          session->CreateCalFileL(session->DefaultFileNameL());
          session->OpenL(session->DefaultFileNameL());
        }
      }); 
      if(err != KErrNone){
        delete session;
        return SPyErr_SetFromSymbianOSErr(err);
      }
    }else{   
      TPtrC filenamePtr((TUint16*)PyUnicode_AsUnicode(filename),PyUnicode_GetSize(filename));
      TInt fileExists = -1;
      TRAP(err, {
        fileExists = isExistingFileL(*session,filenamePtr);
        if(0<=fileExists){
          session->OpenL(TPtrC((TUint16*)PyUnicode_AsUnicode(filename),PyUnicode_GetSize(filename)));
        }
      }); 
      if(err != KErrNone){
        delete session;
        return SPyErr_SetFromSymbianOSErr(err);
      }
      if(fileExists<0){
        delete session;
        PyErr_SetString(PyExc_RuntimeError, "no such file");
        return NULL; 
      }
    }
  }else{
    if(filename && flag[0] == 'c'){
      // Open, create if file doesn't exist.
      TPtrC filenamePtr((TUint16*)PyUnicode_AsUnicode(filename),PyUnicode_GetSize(filename));
      TInt fileExists = -1;
      TRAP(err, {
        fileExists = isExistingFileL(*session,filenamePtr);
        if(0<=fileExists){
          session->OpenL(filenamePtr);
        }else{
          session->CreateCalFileL(filenamePtr);
          session->OpenL(filenamePtr);
        }
      }); 
      if(err != KErrNone){
        delete session;
        return SPyErr_SetFromSymbianOSErr(err);
      }
    }else if(filename && flag[0] == 'n'){
      // Create a new empty file.
      TPtrC filenamePtr((TUint16*)PyUnicode_AsUnicode(filename),PyUnicode_GetSize(filename));
      TInt fileExists = -1;
      TRAP(err, {
        fileExists = isExistingFileL(*session,filenamePtr);
        if(0<=fileExists){
          session->DeleteCalFileL(filenamePtr);
          session->CreateCalFileL(filenamePtr);
          session->OpenL(filenamePtr);
        }else{
          session->CreateCalFileL(filenamePtr);
          session->OpenL(filenamePtr);
        }
      }); 
      if(err != KErrNone){
        delete session;
        return SPyErr_SetFromSymbianOSErr(err);
      }
    }else{
      delete session;
      PyErr_SetString(PyExc_SyntaxError, "illegal parameter combination");
      return NULL; 
    }  
  }
  
  TRAP(err,entryViewAdapter = CCalEntryViewAdapter::NewL(*session));
  if(err != KErrNone){
    delete session;
    return SPyErr_SetFromSymbianOSErr(err);
  } 
  
  Py_BEGIN_ALLOW_THREADS
  TRAP(err,progressError=entryViewAdapter->InitiateL());
  Py_END_ALLOW_THREADS
  if(err != KErrNone){
    delete entryViewAdapter;
    delete session;
    return SPyErr_SetFromSymbianOSErr(err);
  } 
  if(progressError!=KErrNone){
    delete entryViewAdapter;
    delete session;
    return SPyErr_SetFromSymbianOSErr(progressError);
  }
  
  return new_CalendarDb_object(session, entryViewAdapter);
}


/*
 * Returns calendar entry object (indicated by given unique id).
 */ 
static PyObject *
CalendarDb_getitem(CalendarDb_object *self, PyObject *args)
{
  TInt32 key = -1;
  
  if (!PyArg_ParseTuple(args, "i", &key)){ 
    return NULL;
  }
  return new_Entry_object(self, key);  
}


/*
 * Returns number of entries (also modifying/non-originating entries are included).
 */ 
static PyObject *
CalendarDb_entry_count(CalendarDb_object *self, PyObject * /*args*/)
{
  TInt error = KErrNone;
  TCalTime calTime;
  RArray<TCalLocalUid>* uidArray = NULL;
  PyObject* countObj = NULL;
  
  TRAP(error, {
    uidArray = new (ELeave) RArray<TCalLocalUid>(10);
    calTime.SetTimeUtcL(calTime.MinTime());
    self->entryViewAdapter->iEntryView->GetIdsModifiedSinceDateL(calTime, *uidArray);
  });
  if(error != KErrNone){
    delete uidArray;
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  countObj = Py_BuildValue("i", uidArray->Count());
  
  uidArray->Close();
  delete uidArray;