calendarmodule.cpp

python s60 1.4.5版本的源代码

extern "C" PyObject *
Entry_set_start_and_end_datetime(Entry_object* self, PyObject* args)
{
  TInt error = KErrNone;
  TReal startTime = 0;
  TReal endTime = 0;
  TTime startTTime;
  TTime endTTime;
  TCalTime startCalTime;
  TCalTime endCalTime;
  
  if (!PyArg_ParseTuple(args, "dd", &startTime, &endTime)){ 
    return NULL;
  }
  
  pythonRealAsTTime(startTime, startTTime);
  pythonRealAsTTime(endTime, endTTime);
  
  if(EFalse==Check_time_validity(startTTime)){
    PyErr_SetString(PyExc_ValueError, 
                    "illegal start datetime");
    return NULL;
  }
  if(EFalse==Check_time_validity(endTTime)){
    PyErr_SetString(PyExc_ValueError, 
                    "illegal end datetime");
    return NULL;
  }
  
  TRAP(error, {
    startCalTime.SetTimeLocalL(startTTime);
    endCalTime.SetTimeLocalL(endTTime);
    self->entry->SetStartAndEndTimeL(startCalTime, endCalTime);
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Sets entry's priority value.
 *
 * the native calendar application uses following priority values:
 * 1, high
 * 2, normal
 * 3, low
 * others, low (exception:in the calendar (the initial value) 0 = normal, but in the todo app it is not). 
 */
extern "C" PyObject *
Entry_set_priority(Entry_object* self, PyObject* args)
{
  TInt priority = 0;
  TInt error = KErrNone;
  if (!PyArg_ParseTuple(args, "i", &priority)){ 
    return NULL;
  }

  TRAP(error, {
    self->entry->SetPriorityL(priority);
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Returns entry's priority value. 
 */
extern "C" PyObject *
Entry_priority(Entry_object* self, PyObject* /*args*/)
{
  TInt priority = 0;
  TInt error = KErrNone;

  TRAP(error, {
    priority = self->entry->PriorityL();
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  return Py_BuildValue("i", priority);
}


/*
 * Returns the datetime this entry was last modified.
 */
extern "C" PyObject *
Entry_last_modified(Entry_object* self, PyObject* /*args*/)
{
  TInt error = KErrNone;
  TTime lastModifiedTTime;
  
  TRAP(error, {
    TCalTime lastModifiedCalTime = self->entry->LastModifiedDateL();
    lastModifiedTTime = lastModifiedCalTime.TimeLocalL();
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  return ttimeAsPythonFloat(lastModifiedTTime);
}


/*
 * Returns entry's replication status.
 */
extern "C" PyObject *
Entry_replication(Entry_object* self, PyObject* /*args*/)
{
  CCalEntry::TReplicationStatus status;
  TInt error = KErrNone;
  
  TRAP(error, {
    status =  self->entry->ReplicationStatusL();
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  return Py_BuildValue("i", status);  
}


/*
 * Sets entry's replication status.
 */
extern "C" PyObject *
Entry_set_replication(Entry_object* self, PyObject* args)
{  
  TInt error = KErrNone;
  TInt replicationStatus = 0;
  if (!PyArg_ParseTuple(args, "i", &replicationStatus)){ 
    return NULL;
  }
  
  if(replicationStatus!=CCalEntry::EOpen && 
     replicationStatus!=CCalEntry::EPrivate &&
     replicationStatus!=CCalEntry::ERestricted){
     PyErr_SetString(PyExc_ValueError, 
                    "illegal replication status");
     return NULL;    
  }

  TRAP(error, {
    self->entry->SetReplicationStatusL(static_cast<CCalEntry::TReplicationStatus>(replicationStatus)); 
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }

  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Sets the given crossed out datetime for the todo entry.
 */
extern "C" PyObject *
Entry_set_crossed_out(Entry_object* self, PyObject* args)
{
  TInt error = KErrNone;
  TReal crossedOutDate = 0;
  TTime crossedOutTTime;
  TInt completed = 0;
  TBool isCompleted = EFalse;
  TBool isTodo = EFalse;
  if (!PyArg_ParseTuple(args, "id", &completed, &crossedOutDate)){ 
    return NULL;
  }
  
  if(completed != 0){
    isCompleted = ETrue;
  }else{
    isCompleted = EFalse;
  }
  
  TRAP(error, {
    if(self->entry->EntryTypeL()==CCalEntry::ETodo){
      isTodo = ETrue;
    }
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  if(isTodo==EFalse){ 
    PyErr_SetString(PyExc_TypeError, 
                    "cross out property is valid only for todo entries");
    return NULL;
  }
  
  pythonRealAsTTime(crossedOutDate,crossedOutTTime);
  TRAP(error, {
    TCalTime crossedOutCalTime;
    crossedOutCalTime.SetTimeUtcL(crossedOutTTime);
    self->entry->SetCompletedL(isCompleted,crossedOutCalTime);
  });
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Returns crossed out datetime (only for todos).
 */
extern "C" PyObject *
Entry_crossed_out_date(Entry_object* self, PyObject* /*args*/)
{
  TInt error = KErrNone;
  TTime crossOutTTime;
  TBool isTodo = EFalse;
  
  TRAP(error, {
    if(self->entry->EntryTypeL()==CCalEntry::ETodo){
      isTodo = ETrue;
    }
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  if(isTodo==EFalse){ 
    PyErr_SetString(PyExc_TypeError, 
                    "cross out property is valid only for todo entries");
  }
 
  TRAP(error, {
    TCalTime crossOutCalTime = self->entry->CompletedTimeL();  
    crossOutTTime = crossOutCalTime.TimeUtcL();
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  if(crossOutTTime == Time::NullTTime()){
    Py_INCREF(Py_None);
    return Py_None;
  }
  
  return ttimeAsPythonFloat(crossOutTTime);
}


/*
 * Sets an alarm to the entry.
 * -time of the alarm is given as a parameter
 */
extern "C" PyObject *
Entry_set_alarm(Entry_object* self, PyObject* args)
{
  TInt error = KErrNone;
  TReal alarmTime = 0;
  TTime alarmTTime;
  TTime startTTime;
  TCalTime calTime;
  TTimeIntervalMinutes interval;
  CCalAlarm* alarm = NULL;
  TBool timeSet = EFalse;
  
  if (!PyArg_ParseTuple(args, "d", &alarmTime)){ 
    return NULL;
  }
  
  TRAP(error, {
    calTime = self->entry->StartTimeL();
    startTTime = calTime.TimeUtcL();
    if(startTTime != Time::NullTTime()){
      timeSet = ETrue;
    };
  });     
  if(error!=KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  if(timeSet == EFalse){
    PyErr_SetString(PyExc_RuntimeError, "entry's time not set");
    return NULL;
  };
  
  pythonRealUtcAsTTime(alarmTime, alarmTTime);
  
  // must do some checks or crash will follow.
  
  if(EFalse==Check_time_validity(alarmTTime)){
    PyErr_SetString(PyExc_ValueError, 
                    "illegal alarm datetime value");
    return NULL;
  }
  
  if(startTTime.DaysFrom(alarmTTime)>=TTimeIntervalDays(EARLIEST_ALARM_DAY_INTERVAL)){
    PyErr_SetString(PyExc_ValueError, "alarm datetime too early for the entry");
    return NULL;
  }
 
  if(alarmTTime.DateTime().Year()>startTTime.DateTime().Year() ||
    (alarmTTime.DateTime().Year()==startTTime.DateTime().Year() && alarmTTime.DayNoInYear()>startTTime.DayNoInYear())){
    PyErr_SetString(PyExc_ValueError, "alarm datetime too late for the entry");
    return NULL;
  }
 
  // do the actual alarm setting.
  TRAP(error, { 
    startTTime.MinutesFrom(alarmTTime,interval);
    alarm = CCalAlarm::NewL();
    CleanupStack::PushL(alarm);
    alarm->SetTimeOffset(interval);
    self->entry->SetAlarmL(alarm);
    CleanupStack::PopAndDestroy(alarm);
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Returns the alarm datetime.
 */
extern "C" PyObject *
Entry_alarm_datetime(Entry_object* self, PyObject* /*args*/)
{
  TInt error = KErrNone;
  TTime alarmTTime;
  CCalAlarm* alarm = NULL;
  TBool hasAlarm = EFalse;
  
  TRAP(error, {
    alarm = self->entry->AlarmL();
    if(alarm!=NULL){
      CleanupStack::PushL(alarm);
      hasAlarm = ETrue;
      TTimeIntervalMinutes interval = alarm->TimeOffset();
      TCalTime calTime = self->entry->StartTimeL();
      TTime startTTime=calTime.TimeLocalL();
      alarmTTime = startTTime-interval; 
      CleanupStack::PopAndDestroy(alarm); 
    }
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  if(hasAlarm!=EFalse){
    return ttimeAsPythonFloat(alarmTTime);  
  }
  Py_INCREF(Py_None);
  return Py_None; 
}


/*
 * Cancels entry's alarm.
 */
extern "C" PyObject *
Entry_cancel_alarm(Entry_object* self, PyObject* /*args*/)
{
  TInt error = KErrNone;
  
  TRAP(error, {
    self->entry->SetAlarmL(NULL);
  });
  if(error != KErrNone){
    return SPyErr_SetFromSymbianOSErr(error);
  }
  
  Py_INCREF(Py_None);
  return Py_None;
}


/*
 * Puts the given repeat information into the entry.
 */
extern "C" PyObject *
Entry_install_repeat_data(Entry_object* self, 
                          TReal startDate,
                          TReal endDate,
                          TInt interval,
                          TInt repeatIndicator,
                          RArray<TCalTime>* exceptionArray,
                          PyObject* repeatDays,
                          TBool eternalRepeat)
{
  TInt error = KErrNone;
  TTime startTime;
  TTime endTime;
  TCalTime startCalTime;
  TCalTime endCalTime;
  RArray<TDay>* repeatDayArray = NULL;
  RArray<TInt>* repeatDateArray = NULL;
  RArray<TCalRRule::TDayOfMonth>* repeatDayOfMonthArray = NULL;
  
  switch(repeatIndicator){
    case NOT_REPEATED:
      {
        TRAP(error, {
          self->entry->ClearRepeatingPropertiesL();
        });
        if(error != KErrNone){
          return SPyErr_SetFromSymbianOSErr(error);
        }
      }
    break;
    case DAILY_REPEAT:
      {  
        TCalRRule rpt(TCalRRule::EDaily);
        GET_REP_START_AND_END
        SET_REPEAT_DATES
        ADD_REPEAT  
      }
    break;
    case WEEKLY_REPEAT:
      {        
        TCalRRule rpt(TCalRRule::EWeekly);  
        GET_REP_START_AND_END
        SET_REPEAT_DATES
                
        if(repeatDays){
          if(!PyList_Check(repeatDays)){
            PyErr_SetString(PyExc_SyntaxError, 
                            "weekly repeat days must be given in a list");
            return NULL;
          }
          if(PyList_Size(repeatDays)>0){
            TRAP(error, 
                 repeatDayArray = new (ELeave) RArray<TDay>(PyList_Size(repeatDays)));
            if(error!=KErrNone){
              return SPyErr_SetFromSymbianOSErr(error);
            }
          }
          for(TInt i=0;i<PyList_Size(repeatDays);i++){
            PyObject* day = PyList_GetItem(repeatDays, i);
            if(!PyInt_Check(day) || 
               0>PyInt_AsLong(day) || 
               EFalse==isWeekday(PyInt_AsLong(day))){
              PyErr_SetString(PyExc_ValueError, 
                              "bad value for weekly repeat day");
              repeatDayArray->Close();
              delete repeatDayArray;
              return NULL;
            }
            TRAP(error, {
              repeatDayArray->AppendL((static_cast<TDay>(PyInt_AsLong(day))));
            });
            if(error!=KErrNone){
              repeatDayArray->Close();
              delete repeatDayArray;
              return SPyErr_SetFromSymbianOSErr(error);
            }
          }
        }
                
        if(repeatDayArray!=NULL){
          rpt.SetByDay(*repeatDayArray); 
          repeatDayArray->Close();
        }else{
          // must set some day or the program will crash.
          TRAP(error, {
            repeatDayArray = new (ELeave) RArray<TDay>(1);
            CleanupClosePushL(*repeatDayArray);
            repeatDayArray->AppendL(startTime.DayNoInWeek());
            rpt.SetByDay(*repeatDayArray);
            CleanupStack::PopAndDestroy(repeatDayArray);
          });
        };
        delete repeatDayArray;
        if(error!=KErrNone){