calendarmodule.cpp

python s60 1.4.5版本的源代码

  return countObj;
}


/*
 * Deallocate the calendarDb object.
 */
extern "C" {
  static void CalendarDb_dealloc(CalendarDb_object *calendarDb)
  { 
    delete calendarDb->instanceViewAdapter;
    delete calendarDb->entryViewAdapter;
    delete calendarDb->session;   
    
    calendarDb->instanceViewAdapter=NULL;
    calendarDb->entryViewAdapter=NULL;
    calendarDb->session=NULL;
    
    PyObject_Del(calendarDb);
  }
}


/*
 * Create unique (global) id string for calendar entry.
 */
void createUniqueString(TDes8& str)
{
  TTime theMoment;
  theMoment.UniversalTime();
  
  // fulfill the temp with random bits.
  TUint64 temp = Math::Random();
  temp <<= 32;
  temp += Math::Random();
  
  // add bits from microsecond value.
  temp += theMoment.MicroSecondsFrom(Time::MinTTime()).Int64();
  
  // clear the maxbit to avoid negative value.
  temp <<= 1;
  temp >>= 1;
  
  // convert the number to string.
  str.Num(temp); 
}


/*
 * Creates new entry.
 */ 
static PyObject *
CalendarDb_add_entry(CalendarDb_object *self, PyObject *args)
{
  TInt entryType = 0;
  if (!PyArg_ParseTuple(args, "i", &entryType)){ 
    return NULL;
  }

  TBuf8<50> randDesc;
  createUniqueString(randDesc);    
  return new_Entry_object(self, KNullEntryId, static_cast<CCalEntry::TType>(entryType),&randDesc);
}


/*
 * Removes the entry from the database.
 * -note that deleting the originating entry also removes the 
 * modifying entry.
 */ 
static PyObject *
CalendarDb_delete_entry(CalendarDb_object *self, PyObject* args)
{
  TInt error = KErrNone;
  TInt entryUid = 0;
  CCalEntry* entry = NULL;

  if (!PyArg_ParseTuple(args, "i", &entryUid)){ 
    return NULL;
  }
   
  TRAP(error, {
    entry = self->entryViewAdapter->iEntryView->FetchL(entryUid);
    if(entry!=NULL){
      self->entryViewAdapter->iEntryView->DeleteL(*entry);
    }
  });
  if(error != KErrNone){
    delete entry;
    return SPyErr_SetFromSymbianOSErr(error);
  }
  if(entry == NULL){
    PyErr_SetString(PyExc_RuntimeError, "no such entry");
    return NULL;
  }
  delete entry;
  
  Py_INCREF(Py_None);  
  return Py_None;
}


/*
 * Exports vcalendar entries from the database. 
 * -returned string contains entries indicated by content (unique ids)
 * of the tuple given as the parameter.
 */
extern "C" PyObject *
CalendarDb_export_vcals(CalendarDb_object* self, PyObject *args)
{
  RPointerArray<CCalEntry>* entryArray = NULL;
  PyObject* idTuple = NULL;
  PyObject* ret = NULL;
  TInt error = KErrNone;
  CCalEntry* entry = NULL;
  TInt i=0;

  if (!PyArg_ParseTuple(args, "O!", 
                        &PyTuple_Type, &idTuple)){ 
    return NULL;
  }
  
  if(PyTuple_Size(idTuple)<1){
    PyErr_SetString(PyExc_SyntaxError, 
                    "no calendar entry id:s given in the tuple");
    return NULL;
  }
  TRAP(error, 
      entryArray = new (ELeave) RPointerArray<CCalEntry>(PyTuple_Size(idTuple)));
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  // Put the calendar entrys into the entryArray.
  TInt entryCount = PyTuple_Size(idTuple);
  for(TInt i=0;i<entryCount;i++){
    PyObject* idItem = PyTuple_GetItem(idTuple, i);

    if(!PyInt_Check(idItem)){
      for(i=0;i<entryArray->Count();i++){
        delete ((*entryArray)[i]);
      }
      entryArray->Close();
      delete entryArray;
      PyErr_SetString(PyExc_TypeError, "illegal argument in the tuple");
      return NULL;
    };

    TRAP(error, 
      entry = self->entryViewAdapter->iEntryView->FetchL(PyInt_AsLong(idItem)));
    if(error != KErrNone){
      for(i=0;i<entryArray->Count();i++){
        delete ((*entryArray)[i]);
      }
      entryArray->Close();
      delete entryArray;
      return SPyErr_SetFromSymbianOSErr(error);
    }
    if(entry==NULL){
      for(i=0;i<entryArray->Count();i++){
        delete ((*entryArray)[i]);
      }
      entryArray->Close();
      delete entryArray;
      PyErr_SetString(PyExc_ValueError, "specified entry not found");
      return NULL;
    }

    TRAP(error, entryArray->AppendL(entry));
    if(error != KErrNone){
      for(i=0;i<entryArray->Count();i++){
        delete ((*entryArray)[i]);
      }
      entryArray->Close();
      delete entryArray;
      delete entry;
      return SPyErr_SetFromSymbianOSErr(error);
    }
  }

  // Get the vcalendar string.
  TRAP(error, {
    CBufFlat* flatBuf = CBufFlat::NewL(4);
    CleanupStack::PushL(flatBuf);
    RBufWriteStream outputStream(*flatBuf);
    CleanupClosePushL(outputStream);

    CCalDataExchange* dataExchange = CCalDataExchange::NewL(*(self->session));
    CleanupStack::PushL(dataExchange);
    
    TUid dataFormat(KUidVCalendar);
    dataExchange->ExportL(dataFormat,outputStream,*entryArray);

    outputStream.CommitL();        
    
    CleanupStack::PopAndDestroy(); // dataExchange.  
    CleanupStack::PopAndDestroy(); // Close outputStream.  

    ret = Py_BuildValue("s#", (char*)flatBuf->Ptr(0).Ptr(), flatBuf->Size()); 

    CleanupStack::PopAndDestroy(); // flatBuf.  
  });
  for(i=0;i<entryArray->Count();i++){
    delete ((*entryArray)[i]);
  }
  entryArray->Close();
  delete entryArray;
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }

  return ret;
}


/*
 * Imports vcalendar entries (given in the string parameter) to the database. 
 * -returns tuple that contains unique ids of the imported entries.
 */
extern "C" PyObject *
CalendarDb_import_vcals(CalendarDb_object* self, PyObject *args)
{
  RPointerArray<CCalEntry>* entryArray = NULL;
  char* vCalStr = NULL;
  TInt32 vCalStrLength = 0;
  PyObject* idTuple = NULL;
  TInt error = KErrNone;
  TInt flags = 0;
  TInt i=0;
  TInt numOfImportedEntries = 0;

  if (!PyArg_ParseTuple(args, "s#|i",
                        &vCalStr, &vCalStrLength, &flags)){ 
    return NULL;
  }

  TPtrC8 vCalStrPtr((TUint8*)vCalStr, vCalStrLength); 
  
  RMemReadStream inputStream(vCalStrPtr.Ptr(), vCalStrPtr.Length()); 

  TRAP(error, 
    entryArray = new (ELeave) RPointerArray<CCalEntry>(10));
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
    
  TRAP(error, {
    CleanupClosePushL(inputStream);
    CCalDataExchange* exchange = CCalDataExchange::NewL(*(self->session));
    CleanupStack::PushL(exchange);
    exchange->ImportL(KUidVCalendar,inputStream,*entryArray,flags);
    CleanupStack::PopAndDestroy(exchange); 
    CleanupStack::PopAndDestroy(); // Close inputStream.
  });
  if(error!=KErrNone){
    for(i=0;i<entryArray->Count();i++){
      delete ((*entryArray)[i]);
    }
    entryArray->Close();
    delete entryArray;
    return SPyErr_SetFromSymbianOSErr(error);
  }  
  TRAP(error, {
    self->entryViewAdapter->iEntryView->StoreL(*entryArray,numOfImportedEntries);
  });
  if(error!=KErrNone){
    for(i=0;i<entryArray->Count();i++){
      delete ((*entryArray)[i]);
    };
    entryArray->Close();
    delete entryArray;
    return SPyErr_SetFromSymbianOSErr(error);
  }
    
  idTuple = PyTuple_New(numOfImportedEntries);
  if(NULL!=idTuple){
    for(i=0;i<entryArray->Count();i++){
      TCalLocalUid uid = KNullEntryId;
      TRAP(error, {
        uid = ((*entryArray)[i])->LocalUidL();
      });
      if(error!=KErrNone){
        for(i=0;i<entryArray->Count();i++){
          delete ((*entryArray)[i]);
        };
        entryArray->Close();
        delete entryArray;
        Py_DECREF(idTuple);
        return SPyErr_SetFromSymbianOSErr(error);
      }
      if(uid == KNullEntryId){
        continue;
      }
      PyObject* id = Py_BuildValue("i",uid);
      if(id == NULL || PyTuple_SetItem(idTuple, i, id)<0){
        for(i=0;i<entryArray->Count();i++){
          delete ((*entryArray)[i]);
        };
        entryArray->Close();
        delete entryArray;
        Py_DECREF(idTuple);
        return NULL;
      }
    }
  } 
  for(i=0;i<entryArray->Count();i++){
    delete ((*entryArray)[i]);
  }
  entryArray->Close();
  delete entryArray;
  
  if(idTuple==NULL){
    return PyErr_NoMemory();
  }
  return idTuple;
}


/*
 * Do the actual searching.
 */
extern "C" PyObject *
CalendarDb_search_instances(CalendarDb_object* self, TTime startTTime, TTime endTTime, TInt filter, PyObject* searchText)
{
  TInt error = KErrNone;
  TInt progressError = KErrNone;
  TCalTime startCalTime;
  TCalTime endCalTime;
  TDateTime endDate;
  RPointerArray<CCalInstance> instanceArray;
  PyObject* idList = NULL;
  TInt i=0;
      
  if(Check_time_validity(startTTime)==EFalse){
    PyErr_SetString(PyExc_ValueError, "illegal start date");
    return NULL;
  }
  if(Check_time_validity(endTTime)==EFalse){
    PyErr_SetString(PyExc_ValueError, "illegal end date");
    return NULL;
  }
  
  if(filter==0){
    filter = CalCommon::EIncludeAll;
  }
   
  endDate = endTTime.DateTime();
  TInt endDateday = endDate.Day();
  TInt  totalDayMonth = Time::DaysInMonth(endDate.Year(), endDate.Month());
  /* Increment return value of TDateTime::Day() by one as it 
   * returns one day lesser than actual day.
   */
  if(totalDayMonth == (endDateday + 1)){
    if(endDate.Month()==EDecember){
      endDate.SetYear(endDate.Year() + 1);
    }
    endDate.SetDay(1);
    endDate.SetMonth(getNextMonth(endDate.Month()));
  }else{
    endDate.SetDay(endDate.Day()+1);
  }
 
  endTTime = endDate;
  startTTime=truncToDate(startTTime);
  endTTime=truncToDate(endTTime);
   
  TRAP(error, {
    startCalTime.SetTimeUtcL(startTTime);
    endCalTime.SetTimeUtcL(endTTime);
  });
  if(error!=KErrNone){
    instanceArray.Close();
    return SPyErr_SetFromSymbianOSErr(error);  
  }
  CalCommon::TCalTimeRange timeRange(startCalTime,endCalTime);
   
  if(self->instanceViewAdapter == NULL){
    Py_BEGIN_ALLOW_THREADS
    TRAP(error, {
      self->instanceViewAdapter = CCalInstanceViewAdapter::NewL(*(self->session));
      progressError = self->instanceViewAdapter->InitiateL();
    });
    Py_END_ALLOW_THREADS
    if(error!=KErrNone){
      instanceArray.Close();
      delete self->instanceViewAdapter;
      self->instanceViewAdapter = NULL;
      return SPyErr_SetFromSymbianOSErr(error);      
    }  
    if(progressError!=KErrNone){
      instanceArray.Close();
      delete self->instanceViewAdapter;
      self->instanceViewAdapter = NULL;
      return SPyErr_SetFromSymbianOSErr(progressError);      
    }    
  }
  TRAP(error, {
    if(searchText==NULL){
      self->instanceViewAdapter->iInstanceView->FindInstanceL(instanceArray,
                                                              filter,
                                                              timeRange);
    }else{
      TPtrC searchTextPtr((TUint16*) PyUnicode_AsUnicode(searchText), 
                          PyUnicode_GetSize(searchText));
      CCalInstanceView::TCalSearchParams searchParams(searchTextPtr,CalCommon::EFoldedTextSearch);
      self->instanceViewAdapter->iInstanceView->FindInstanceL(instanceArray,
                                                              filter,
                                                              timeRange,
                                                              searchParams);
    }
  });
  if(error!=KErrNone){
    DELETE_INSTANCES
    return SPyErr_SetFromSymbianOSErr(error);     
  }
                                                        
  idList = PyList_New(instanceArray.Count()); 
  if(idList == NULL){
    DELETE_INSTANCES
    return PyErr_NoMemory();
  }
  
  TCalLocalUid uid;
  TTime instStartTTime;
  for(i=0;i<instanceArray.Count();i++){
    CCalInstance* instance = instanceArray[i];
    CCalEntry& entry = instance->Entry();
    
    TRAP(error, {
      uid = entry.LocalUidL();
      error = GetInstanceStartTime(instance,instStartTTime);    
    });
    if(error!=KErrNone){
      DELETE_INSTANCES
      Py_DECREF(idList);
      return SPyErr_SetFromSymbianOSErr(error);  
    }
      
    PyObject* instanceInfo =
      Py_BuildValue("{s:i,s:d}",(const char*)(&KUniqueId)->Ptr(),
                                uid,
                                (const char*)(&KDateTime)->Ptr(), 
                                time_as_UTC_TReal(instStartTTime));
                                
    if(instanceInfo==NULL){
      Py_DECREF(idList);
      DELETE_INSTANCES
      return NULL;
    }
                                 
    if(PyList_SetItem(idList, i, instanceInfo)<0){
      Py_DECREF(idList);
      DELETE_INSTANCES
      return NULL;
    }                              
  }
  
  DELETE_INSTANCES
 
  return idList;
}


/*
 * Finds instances (that occur between the specified time interval) 
 * (optionally by search string).
 */
extern "C" PyObject *
CalendarDb_find_instances(CalendarDb_object* self, PyObject *args)
{
  TReal startDate = 0;
  TReal endDate = 0;
  TInt filter = 0;
  TTime startTTime;
  TTime endTTime;
  PyObject* searchText = NULL;
   
  if (!PyArg_ParseTuple(args, "dd|Ui", &startDate, &endDate, &searchText, &filter)){ 
    return NULL;
  }