mozilla
/
pjs
зеркало из https://github.com/mozilla/pjs.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Renamed classes with Julian.* in front to nsCal.*.

This commit is contained in:
jsun%netscape.com 1998-09-28 20:47:07 +00:00
Родитель 652033e5f8
Коммит eab85ea7c9
49 изменённых файлов: 287 добавлений и 287 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

6
calendar/modules/core/ical/inc/capiredr.h
Просмотреть файл

@ -64,7 +64,7 @@ private:
t_int32 m_ChunkIndex;
/** encoding of stream */
JulianUtility::MimeEncoding m_Encoding;
nsCalUtility::MimeEncoding m_Encoding;
JulianPtrArray * m_Chunks;
@ -90,7 +90,7 @@ public:
** CONSTRUCTORS and DESTRUCTORS
**---------------------------*/
ICalCAPIReader(PRMonitor * monitor,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
virtual ~ICalCAPIReader();
/*-----------------------------
@ -100,7 +100,7 @@ public:
virtual void * getMonitor() { return m_Monitor; }
void setFinished() { m_bFinished = TRUE; }
void setEncoding(JulianUtility::MimeEncoding encoding) { m_Encoding = encoding; }
void setEncoding(nsCalUtility::MimeEncoding encoding) { m_Encoding = encoding; }
t_bool isFinished() const { return m_bFinished; }
/**
* Sets a the buffer to read from.

6
calendar/modules/core/ical/inc/duprprty.h
Просмотреть файл

@ -36,8 +36,8 @@
class DurationProperty: public StandardProperty
{
private:
/** the Julian_Duration value of the property */
Julian_Duration m_Duration;
/** the nsCalDuration value of the property */
nsCalDuration m_Duration;
/**
* Default constructor
@ -57,7 +57,7 @@ public:
* @param value value of property
* @param parameters parameters of property
*/
DurationProperty(Julian_Duration value, JulianPtrArray * parameters);
DurationProperty(nsCalDuration value, JulianPtrArray * parameters);
/**
* Destructor

4
calendar/modules/core/ical/inc/icalcomp.h
Просмотреть файл

@ -114,8 +114,8 @@ public:
*/
virtual UnicodeString & parse(ICalReader * brFile, UnicodeString & sMethod,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE, JulianUtility::MimeEncoding encoding =
JulianUtility::MimeEncoding_7bit)
t_bool bIgnoreBeginError = FALSE, nsCalUtility::MimeEncoding encoding =
nsCalUtility::MimeEncoding_7bit)
{
PR_ASSERT(FALSE);
if (brFile != NULL && vTimeZones != NULL

4
calendar/modules/core/ical/inc/icalsrdr.h
Просмотреть файл

@ -62,7 +62,7 @@ private:
t_int32 m_mark;
/** encoding of stream */
JulianUtility::MimeEncoding m_Encoding;
nsCalUtility::MimeEncoding m_Encoding;
/**
* Default constructor. Made private to hide from clients.
@ -78,7 +78,7 @@ public:
* @param string string to read from
*/
ICalStringReader(const char * string,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Mark current position in string

2
calendar/modules/core/ical/inc/jparser.h
Просмотреть файл

@ -41,7 +41,7 @@ class JulianParser
private:
/*char * m_Buffer;*/
static JulianUtility::MimeEncoding stringToEncodingType(UnicodeString & propVal);
static nsCalUtility::MimeEncoding stringToEncodingType(UnicodeString & propVal);
JulianPtrArray * m_OutCalendars;
ICalCAPIReader * m_Reader;

2
calendar/modules/core/ical/inc/nscal.h
Просмотреть файл

@ -203,7 +203,7 @@ public:
*
*/
void parse(ICalReader * brFile, UnicodeString & fileName,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Returns the error log.

32
calendar/modules/core/ical/inc/orgnzr.h
Просмотреть файл

@ -22,8 +22,8 @@
* 4/7/98 11:16:49 AM
*/
#ifndef __JULIANORGANIZER_H_
#define __JULIANORGANIZER_H_
#ifndef __NSCALORGANIZER_H_
#define __NSCALORGANIZER_H_
#include "jlog.h"
#include "prprty.h"
@ -33,7 +33,7 @@
* Similar to the Attendee property, but doesn't
* have as much state.
*/
class JulianOrganizer : public ICalProperty
class nsCalOrganizer : public ICalProperty
{
private:
/*-----------------------------
@ -41,7 +41,7 @@ private:
**---------------------------*/
/**
* the name of the JulianOrganizer. Whatever is to the right of the colon
* the name of the nsCalOrganizer. Whatever is to the right of the colon
* the name must be a URL. Field must be filled to be valid Attendee.
*/
UnicodeString m_Name;
@ -64,25 +64,25 @@ private:
/** ptr to log file to write errors to */
JLog * m_Log;
static const t_int32 ms_cJulianOrganizerName;/* = 'N';*/
static const t_int32 ms_cJulianOrganizerDir; /* = 'l'; 'el'*/
static const t_int32 ms_cJulianOrganizerSentBy;/* = 's';*/
static const t_int32 ms_cJulianOrganizerCN;/* = 'C';*/
static const t_int32 ms_cJulianOrganizerLanguage;/* = 'm';*/
static const t_int32 ms_cJulianOrganizerDisplayName;/* = 'z';*/
static const t_int32 ms_cnsCalOrganizerName;/* = 'N';*/
static const t_int32 ms_cnsCalOrganizerDir; /* = 'l'; 'el'*/
static const t_int32 ms_cnsCalOrganizerSentBy;/* = 's';*/
static const t_int32 ms_cnsCalOrganizerCN;/* = 'C';*/
static const t_int32 ms_cnsCalOrganizerLanguage;/* = 'm';*/
static const t_int32 ms_cnsCalOrganizerDisplayName;/* = 'z';*/
/*-----------------------------
** PRIVATE METHODS
**---------------------------*/
JulianOrganizer(JulianOrganizer & that);
nsCalOrganizer(nsCalOrganizer & that);
public:
/*-----------------------------
** CONSTRUCTORS and DESTRUCTORS
**---------------------------*/
JulianOrganizer(JLog * initLog = 0);
~JulianOrganizer();
nsCalOrganizer(JLog * initLog = 0);
~nsCalOrganizer();
/*---------- To satisfy ICalProperty interface ----------*/
/**
@ -164,14 +164,14 @@ public:
**---------------------------*/
/**
* Sets JulianOrganizer name.
* Sets nsCalOrganizer name.
* @param sName new Attendee name
*
*/
void setName(UnicodeString sName);
/**
* Returns JulianOrganizer name.
* Returns nsCalOrganizer name.
*
* @return Attendee name
*/
@ -269,5 +269,5 @@ public:
**---------------------------*/
};
#endif /* __JULIANORGANIZER_H_ */
#endif /* __NSCALORGANIZER_H_ */

10
calendar/modules/core/ical/inc/period.h
Просмотреть файл

@ -44,7 +44,7 @@ private:
DateTime m_DTEnd;
/** the duration of the period */
Julian_Duration m_Duration;
nsCalDuration m_Duration;
/*-----------------------------
** PRIVATE METHODS
@ -127,9 +127,9 @@ public:
/**
* Return duration (may be invalid).
*
* @return Julian_Duration
* @return nsCalDuration
*/
Julian_Duration getDuration() { return m_Duration; }
nsCalDuration getDuration() { return m_Duration; }
/**
* Set start time
@ -147,7 +147,7 @@ public:
* Set duration
* @param d new duration value
*/
void setDuration(Julian_Duration d);
void setDuration(nsCalDuration d);
/**
* Set period by passing string.
@ -210,7 +210,7 @@ public:
/**
* Returns period in iCal period format of "start/end", where
* start is UTC ISO8601 datetime format and end is either
* a UTC IS08601 datetime format or an iCal Julian_Duration string.
* a UTC IS08601 datetime format or an iCal nsCalDuration string.
*
* @return output string
*/

14
calendar/modules/core/ical/inc/rcrrence.h
Просмотреть файл

@ -50,7 +50,7 @@ class Recurrence
public:
/* moved the Recurrence Type constants to JulianUtility. */
/* moved the Recurrence Type constants to nsCalUtility. */
#if 0
/**
* Creates a Recurrence object specified by the given string.
@ -60,7 +60,7 @@ public:
* @param duration the time between start and stopdate
* @param ruleString the recurrence rule string to parse
*/
Recurrence(DateTime startDate, DateTime stopDate, Julian_Duration * duration,
Recurrence(DateTime startDate, DateTime stopDate, nsCalDuration * duration,
UnicodeString & ruleString);
/**
@ -70,7 +70,7 @@ public:
* @param duration the time between start and stopdate
* @param ruleString the recurrence rule string to parse
*/
Recurrence(DateTime startDate, Julian_Duration * duration, UnicodeString & ruleString);
Recurrence(DateTime startDate, nsCalDuration * duration, UnicodeString & ruleString);
#endif
/**
* Creates a Recurrence object specified by the given string.
@ -199,8 +199,8 @@ private:
static const t_int32 ms_iUNSET;
/* Variables that correspond directly to properties defined in the spec */
t_int32 m_iType; /* init to JulianUtility::RT_NONE */
Julian_Duration * m_Interval; /* init to NULL */
t_int32 m_iType; /* init to nsCalUtility::RT_NONE */
nsCalDuration * m_Interval; /* init to NULL */
t_int32 m_iCount; /* init to ms_iUNSET */
t_int32 m_iWkSt; /* init to Calendar::MONDAY */
DateTime m_Until; /* init to Invalid DateTime */
@ -244,7 +244,7 @@ private:
/* Variables for storing DTSTART, DTEND and DURATION */
DateTime m_StartDate;
DateTime m_StopDate;
Julian_Duration * m_Duration; /* init to NULL */
nsCalDuration * m_Duration; /* init to NULL */
/* cache validity */
t_bool m_bParseValid;
@ -291,7 +291,7 @@ private:
/**
* Sets interval to i, depending on m_iType. For example,
* if m_iType is set to JulianUtility::RT_YEARLY and i is 2,
* if m_iType is set to nsCalUtility::RT_YEARLY and i is 2,
* then the interval is every 2 years.
* @param i value of interval w/respect to m_iType
*/

28
calendar/modules/core/ical/inc/recid.h
Просмотреть файл

@ -31,15 +31,15 @@
#include "jlog.h"
/**
* JulianRecurrenceID implements the RecurrenceID property. The RecurrenceID
* nsCalRecurrenceID implements the RecurrenceID property. The RecurrenceID
* must have a DateTime value. It can optionally have a RANGE value set to
* THISANDPRIOR or THISANDFUTURE. A RecurrenceID without a RANGE has its
* range value set to NONE.
* The JulianRecurrenceID must implement the ICalProperty interface.
* The nsCalRecurrenceID must implement the ICalProperty interface.
*
* @see ICalProperty
*/
class JulianRecurrenceID : public ICalProperty
class nsCalRecurrenceID : public ICalProperty
{
public:
/** an enumeration of the RANGE parameter */
@ -51,7 +51,7 @@ private:
**---------------------------*/
/** range parameter value */
JulianRecurrenceID::RANGE m_Range;
nsCalRecurrenceID::RANGE m_Range;
/** datetime value */
DateTime m_DateTime;
@ -73,14 +73,14 @@ private:
#if 0
/* hide constructor from clients */
JulianRecurrenceID();
nsCalRecurrenceID();
#endif
/**
* Copy constructor.
* @param that JulianRecurrenceID to copy
* @param that nsCalRecurrenceID to copy
*/
JulianRecurrenceID(JulianRecurrenceID & that);
nsCalRecurrenceID(nsCalRecurrenceID & that);
public:
@ -92,7 +92,7 @@ public:
* Constructor. Create a RecurrenceID with log set to initLog
* @param initLog log file to write errors to
*/
JulianRecurrenceID(JLog * initLog = 0);
nsCalRecurrenceID(JLog * initLog = 0);
/**
* Constructor. Create a RecurrenceID with log set to initLog
@ -100,12 +100,12 @@ public:
* @param initLog log file to write errors to
* @param range initial RANGE value
*/
JulianRecurrenceID(DateTime datetime, JLog * initLog, RANGE range = RANGE_NONE);
nsCalRecurrenceID(DateTime datetime, JLog * initLog, RANGE range = RANGE_NONE);
/**
* Destructor
*/
~JulianRecurrenceID();
~nsCalRecurrenceID();
/*-----------------------------
** ACCESSORS (GET AND SET)
@ -116,14 +116,14 @@ public:
*
* @return current RANGE value
*/
JulianRecurrenceID::RANGE getRange() const { return m_Range; }
nsCalRecurrenceID::RANGE getRange() const { return m_Range; }
/**
* Sets RANGE value
* @param range new range value
*
*/
void setRange(JulianRecurrenceID::RANGE range) { m_Range = range; }
void setRange(nsCalRecurrenceID::RANGE range) { m_Range = range; }
/**
* Sets DateTime value.
@ -224,7 +224,7 @@ public:
*
* @return RANGE enumeration value of sRange
*/
static JulianRecurrenceID::RANGE stringToRange(UnicodeString & sRange);
static nsCalRecurrenceID::RANGE stringToRange(UnicodeString & sRange);
/**
* Converts RANGE to string. Returns "" for NONE.
@ -233,7 +233,7 @@ public:
*
* @return output range string
*/
static UnicodeString & rangeToString(JulianRecurrenceID::RANGE range, UnicodeString & out);
static UnicodeString & rangeToString(nsCalRecurrenceID::RANGE range, UnicodeString & out);
};

6
calendar/modules/core/ical/inc/tmbevent.h
Просмотреть файл

@ -145,8 +145,8 @@ public:
*/
virtual UnicodeString & parse(ICalReader * brFile, UnicodeString & sMethod,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE, JulianUtility::MimeEncoding encoding =
JulianUtility::MimeEncoding_7bit)
t_bool bIgnoreBeginError = FALSE, nsCalUtility::MimeEncoding encoding =
nsCalUtility::MimeEncoding_7bit)
{
PR_ASSERT(FALSE);
if (brFile != NULL && vTimeZones != NULL && sMethod.size() > 0
@ -281,7 +281,7 @@ public:
UnicodeString & parseType(UnicodeString & sType, ICalReader * brFile,
UnicodeString & sMethod, UnicodeString & parseStatus, JulianPtrArray * vTimeZones,
t_bool bIgnoreBeginError = FALSE,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Prints properties of an CANCEL message, specifically

2
calendar/modules/core/ical/inc/tzpart.h
Просмотреть файл

@ -86,7 +86,7 @@ public:
virtual UnicodeString & parse(ICalReader * brFile, UnicodeString & sType,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Returns a clone of this object

12
calendar/modules/core/ical/inc/valarm.h
Просмотреть файл

@ -202,7 +202,7 @@ public:
virtual UnicodeString & parse(ICalReader * brFile, UnicodeString & sType,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Returns a clone of this object
@ -300,9 +300,9 @@ public:
VAlarm::ACTION getAction() const { return m_Action; }
void setAction(VAlarm::ACTION action) { m_Action = action; }
/* Julian_Duration */
Julian_Duration getDuration() const;
void setDuration(Julian_Duration s, JulianPtrArray * parameters = 0);
/* nsCalDuration */
nsCalDuration getDuration() const;
void setDuration(nsCalDuration s, JulianPtrArray * parameters = 0);
ICalProperty * getDurationProperty() const { return m_Duration; }
/* Repeat */
@ -312,8 +312,8 @@ public:
/* Trigger */
/* can be date-time or duration */
Julian_Duration getTriggerAsDuration() const;
void setTriggerAsDuration(Julian_Duration s, JulianPtrArray * parameters = 0);
nsCalDuration getTriggerAsDuration() const;
void setTriggerAsDuration(nsCalDuration s, JulianPtrArray * parameters = 0);
void setTriggerAsDateTime(DateTime s);
ICalProperty * getTriggerProperty() const { return m_Trigger; }
DateTime getTriggerAsDateTime(DateTime startTime) const;

8
calendar/modules/core/ical/inc/vevent.h
Просмотреть файл

@ -83,7 +83,7 @@ public:
UnicodeString & parse(ICalReader * brFile, UnicodeString & sMethod,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Returns a clone of this object
@ -207,8 +207,8 @@ public:
ICalProperty * getDTEndProperty() const { return m_DTEnd; }
/* DURATION */
Julian_Duration getDuration() const;
void setDuration(Julian_Duration s, JulianPtrArray * parameters = 0);
nsCalDuration getDuration() const;
void setDuration(nsCalDuration s, JulianPtrArray * parameters = 0);
/*ICalProperty * getDurationProperty() const { return m_Duration; }*/
/* GEO */
@ -315,7 +315,7 @@ private:
DateTime m_origMyDTEnd;
/** used for initial parse only to calculate first DTEnd, then discarded */
Julian_Duration * m_TempDuration;
nsCalDuration * m_TempDuration;
/*-------------------------------------------------
* DATA MEMBER (to augment TimeBasedEvent)

8
calendar/modules/core/ical/inc/vfrbsy.h
Просмотреть файл

@ -261,7 +261,7 @@ public:
virtual UnicodeString & parse(ICalReader * brFile, UnicodeString & method,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Returns a clone of this object
@ -375,8 +375,8 @@ public:
*/
/* DURATION */
Julian_Duration getDuration() const;
void setDuration(Julian_Duration s, JulianPtrArray * parameters = 0);
nsCalDuration getDuration() const;
void setDuration(nsCalDuration s, JulianPtrArray * parameters = 0);
/* ICalProperty * getDurationProperty() const { return m_Duration; } */
/* DTSTART */
@ -515,7 +515,7 @@ private:
UnicodeString m_sMethod;
/** used for initial parse only to calculate first DTEnd, then discarded */
Julian_Duration * m_TempDuration;
nsCalDuration * m_TempDuration;
/* -- MEMBERS -- */
JulianPtrArray * m_AttendeesVctr;

2
calendar/modules/core/ical/inc/vjournal.h
Просмотреть файл

@ -111,7 +111,7 @@ public:
UnicodeString & parse(ICalReader * brFile, UnicodeString & sMethod,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Returns a clone of this object

2
calendar/modules/core/ical/inc/vtimezne.h
Просмотреть файл

@ -89,7 +89,7 @@ public:
virtual UnicodeString & parse(ICalReader * brFile, UnicodeString & sType,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Returns a clone of this object

8
calendar/modules/core/ical/inc/vtodo.h
Просмотреть файл

@ -44,7 +44,7 @@ private:
DateTime m_origMyDue;
/** used for initial parse only to calculate first Due, then discarded */
Julian_Duration * m_TempDuration;
nsCalDuration * m_TempDuration;
/*-------------------------------------------------
* DATA MEMBER (to augment TimeBasedEvent)
@ -163,7 +163,7 @@ public:
UnicodeString & parse(ICalReader * brFile, UnicodeString & sMethod,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones = 0,
t_bool bIgnoreBeginError = FALSE,
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit);
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit);
/**
* Returns a clone of this object
@ -291,8 +291,8 @@ public:
ICalProperty * getDueProperty() const { return m_Due; }
/* DURATION */
Julian_Duration getDuration() const;
void setDuration(Julian_Duration s, JulianPtrArray * parameters = 0);
nsCalDuration getDuration() const;
void setDuration(nsCalDuration s, JulianPtrArray * parameters = 0);
/*ICalProperty * getDurationProperty() const { return m_Duration; }*/
/* GEO */

10
calendar/modules/core/ical/src/attendee.cpp
Просмотреть файл

@ -264,7 +264,7 @@ void Attendee::addParamValList(UnicodeString & paramValList, t_int32 hashCode)
break;
}
}
JulianUtility::stripDoubleQuotes(u); // double quote property
nsCalUtility::stripDoubleQuotes(u); // double quote property
if (JulianKeyword::Instance()->ms_ATOM_DELEGATED_TO == hashCode)
{
@ -450,7 +450,7 @@ void Attendee::setParam(UnicodeString & paramName,
if (m_Log) m_Log->logError(JulianLogErrorMessage::Instance()->ms_iDuplicatedParameter,
JulianKeyword::Instance()->ms_sATTENDEE, paramName, 100);
}
JulianUtility::stripDoubleQuotes(paramVal); // double quote property
nsCalUtility::stripDoubleQuotes(paramVal); // double quote property
setSentBy(paramVal);
}
else if (JulianKeyword::Instance()->ms_ATOM_DIR == hashCode)
@ -460,7 +460,7 @@ void Attendee::setParam(UnicodeString & paramName,
if (m_Log) m_Log->logError(JulianLogErrorMessage::Instance()->ms_iDuplicatedParameter,
JulianKeyword::Instance()->ms_sATTENDEE, paramName, 100);
}
JulianUtility::stripDoubleQuotes(paramVal); // double quote property
nsCalUtility::stripDoubleQuotes(paramVal); // double quote property
setDir(paramVal);
}
else if (ICalProperty::IsXToken(paramName))
@ -765,12 +765,12 @@ UnicodeString Attendee::formatChar(t_int32 c)
JulianKeyword::Instance()->ms_sMEMBER, xp, u);
case ms_cAttendeeDir:
s = m_Dir;
s = JulianUtility::addDoubleQuotes(s);
s = nsCalUtility::addDoubleQuotes(s);
return ICalProperty::parameterToCalString(
JulianKeyword::Instance()->ms_sDIR, s, u);
case ms_cAttendeeSentBy:
s = m_SentBy;
s = JulianUtility::addDoubleQuotes(s);
s = nsCalUtility::addDoubleQuotes(s);
return ICalProperty::parameterToCalString(
JulianKeyword::Instance()->ms_sSENTBY, s, u);
case ms_cAttendeeCN:

4
calendar/modules/core/ical/src/bydmgntr.cpp
Просмотреть файл

@ -31,7 +31,7 @@
ByDayMonthlyGenerator::ByDayMonthlyGenerator()
: DateGenerator(JulianUtility::RT_MONTHLY, 0),
: DateGenerator(nsCalUtility::RT_MONTHLY, 0),
m_aiParams(0),
m_iWkSt((t_int32) Calendar::SUNDAY)
{}
@ -39,7 +39,7 @@ ByDayMonthlyGenerator::ByDayMonthlyGenerator()
//---------------------------------------------------------------------
t_int32
ByDayMonthlyGenerator::getInterval() const { return JulianUtility::RT_DAILY; }
ByDayMonthlyGenerator::getInterval() const { return nsCalUtility::RT_DAILY; }
//---------------------------------------------------------------------
// TODO: crash proof it

4
calendar/modules/core/ical/src/bydwgntr.cpp
Просмотреть файл

@ -29,7 +29,7 @@
ByDayWeeklyGenerator::ByDayWeeklyGenerator()
:
DateGenerator(JulianUtility::RT_WEEKLY, 0),
DateGenerator(nsCalUtility::RT_WEEKLY, 0),
m_aiParams(0),
m_iWkSt((t_int32) Calendar::SUNDAY)
{}
@ -37,7 +37,7 @@ ByDayWeeklyGenerator::ByDayWeeklyGenerator()
//---------------------------------------------------------------------
t_int32
ByDayWeeklyGenerator::getInterval() const { return JulianUtility::RT_DAILY; }
ByDayWeeklyGenerator::getInterval() const { return nsCalUtility::RT_DAILY; }
//---------------------------------------------------------------------

4
calendar/modules/core/ical/src/bydygntr.cpp
Просмотреть файл

@ -30,7 +30,7 @@
ByDayYearlyGenerator::ByDayYearlyGenerator()
:
DateGenerator(JulianUtility::RT_YEARLY, 0),
DateGenerator(nsCalUtility::RT_YEARLY, 0),
m_aiParams(0),
m_iWkSt((t_int32) Calendar::SUNDAY)
{}
@ -39,7 +39,7 @@ ByDayYearlyGenerator::ByDayYearlyGenerator()
//---------------------------------------------------------------------
t_int32
ByDayYearlyGenerator::getInterval() const { return JulianUtility::RT_DAILY; }
ByDayYearlyGenerator::getInterval() const { return nsCalUtility::RT_DAILY; }
//---------------------------------------------------------------------
// TODO: crash proof

4
calendar/modules/core/ical/src/byhgntr.cpp
Просмотреть файл

@ -30,14 +30,14 @@
ByHourGenerator::ByHourGenerator()
:
DateGenerator(JulianUtility::RT_DAILY, 0),
DateGenerator(nsCalUtility::RT_DAILY, 0),
m_aiParams(0)
{}
//---------------------------------------------------------------------
t_int32
ByHourGenerator::getInterval() const { return JulianUtility::RT_HOURLY; }
ByHourGenerator::getInterval() const { return nsCalUtility::RT_HOURLY; }
//---------------------------------------------------------------------

4
calendar/modules/core/ical/src/bymdgntr.cpp
Просмотреть файл

@ -29,14 +29,14 @@
ByMonthDayGenerator::ByMonthDayGenerator()
:
DateGenerator(JulianUtility::RT_MONTHLY, 0),
DateGenerator(nsCalUtility::RT_MONTHLY, 0),
m_aiParams(0)
{}
//---------------------------------------------------------------------
t_int32
ByMonthDayGenerator::getInterval() const { return JulianUtility::RT_DAILY; }
ByMonthDayGenerator::getInterval() const { return nsCalUtility::RT_DAILY; }
//---------------------------------------------------------------------

4
calendar/modules/core/ical/src/bymgntr.cpp
Просмотреть файл

@ -30,14 +30,14 @@
ByMinuteGenerator::ByMinuteGenerator()
:
DateGenerator(JulianUtility::RT_HOURLY, 0),
DateGenerator(nsCalUtility::RT_HOURLY, 0),
m_aiParams(0)
{}
//---------------------------------------------------------------------
t_int32
ByMinuteGenerator::getInterval() const { return JulianUtility::RT_MINUTELY; }
ByMinuteGenerator::getInterval() const { return nsCalUtility::RT_MINUTELY; }
//---------------------------------------------------------------------

4
calendar/modules/core/ical/src/bymogntr.cpp
Просмотреть файл

@ -29,14 +29,14 @@
ByMonthGenerator::ByMonthGenerator()
:
DateGenerator(JulianUtility::RT_YEARLY, 0),
DateGenerator(nsCalUtility::RT_YEARLY, 0),
m_aiParams(0)
{}
//---------------------------------------------------------------------
t_int32
ByMonthGenerator::getInterval() const { return JulianUtility::RT_MONTHLY; }
ByMonthGenerator::getInterval() const { return nsCalUtility::RT_MONTHLY; }
//---------------------------------------------------------------------

4
calendar/modules/core/ical/src/bywngntr.cpp
Просмотреть файл

@ -29,14 +29,14 @@
ByWeekNoGenerator::ByWeekNoGenerator()
:
DateGenerator(JulianUtility::RT_YEARLY, 0),
DateGenerator(nsCalUtility::RT_YEARLY, 0),
m_aiParams(0)
{}
//---------------------------------------------------------------------
t_int32
ByWeekNoGenerator::getInterval() const { return JulianUtility::RT_WEEKLY; }
ByWeekNoGenerator::getInterval() const { return nsCalUtility::RT_WEEKLY; }
//---------------------------------------------------------------------

4
calendar/modules/core/ical/src/byydgntr.cpp
Просмотреть файл

@ -29,14 +29,14 @@
ByYearDayGenerator::ByYearDayGenerator()
:
DateGenerator(JulianUtility::RT_YEARLY, 0),
DateGenerator(nsCalUtility::RT_YEARLY, 0),
m_aiParams(0)
{}
//---------------------------------------------------------------------
t_int32
ByYearDayGenerator::getInterval() const { return JulianUtility::RT_DAILY; }
ByYearDayGenerator::getInterval() const { return nsCalUtility::RT_DAILY; }
//---------------------------------------------------------------------

4
calendar/modules/core/ical/src/capiredr.cpp
Просмотреть файл

@ -53,7 +53,7 @@ ICalCAPIReader::AddChunk(UnicodeString * u)
//---------------------------------------------------------------------
ICalCAPIReader::ICalCAPIReader(PRMonitor * monitor,
JulianUtility::MimeEncoding encoding)
nsCalUtility::MimeEncoding encoding)
{
m_Monitor = monitor;
m_bFinished = FALSE;
@ -137,7 +137,7 @@ t_int8 ICalCAPIReader::read(ErrorCode & status)
// return index of this
status = ZERO_ERROR;
if (m_Encoding == JulianUtility::MimeEncoding_QuotedPrintable)
if (m_Encoding == nsCalUtility::MimeEncoding_QuotedPrintable)
{
if ((string)[(TextOffset) m_Pos] == '=')
{

8
calendar/modules/core/ical/src/deftgntr.cpp
Просмотреть файл

@ -31,14 +31,14 @@
//t_int32 DefaultGenerator::m_iParamsLen = 3;
DefaultGenerator::DefaultGenerator()
: DateGenerator(JulianUtility::RT_MONTHLY, 3),
: DateGenerator(nsCalUtility::RT_MONTHLY, 3),
isActive(FALSE)
{}
//---------------------------------------------------------------------
t_int32
DefaultGenerator::getInterval() const { return JulianUtility::RT_MONTHLY; }
DefaultGenerator::getInterval() const { return nsCalUtility::RT_MONTHLY; }
//---------------------------------------------------------------------
@ -48,7 +48,7 @@ DefaultGenerator::generate(DateTime * start, JulianPtrArray & dateVector,
{
t_int32 i;
DateTime * t;
Julian_Duration * d;
nsCalDuration * d;
PR_ASSERT(start != 0);
PR_ASSERT(m_aiParams != 0);
@ -59,7 +59,7 @@ DefaultGenerator::generate(DateTime * start, JulianPtrArray & dateVector,
}
t = new DateTime(start->getTime()); PR_ASSERT(t != 0);
d = new Julian_Duration(m_aiParams[0], m_aiParams[1]); PR_ASSERT(d != 0);
d = new nsCalDuration(m_aiParams[0], m_aiParams[1]); PR_ASSERT(d != 0);
dateVector.Add(new DateTime(t->getTime()));

4
calendar/modules/core/ical/src/duprprty.cpp
Просмотреть файл

@ -45,7 +45,7 @@ DurationProperty::DurationProperty(const DurationProperty & that)
//---------------------------------------------------------------------
DurationProperty::DurationProperty(Julian_Duration value, JulianPtrArray * parameters)
DurationProperty::DurationProperty(nsCalDuration value, JulianPtrArray * parameters)
: StandardProperty(parameters)
{
//PR_ASSERT(value != 0);
@ -75,7 +75,7 @@ void DurationProperty::setValue(void * value)
PR_ASSERT(value != 0);
if (value != 0)
{
m_Duration = *((Julian_Duration *) value);
m_Duration = *((nsCalDuration *) value);
}
}

2
calendar/modules/core/ical/src/freebusy.cpp
Просмотреть файл

@ -377,7 +377,7 @@ DateTime Freebusy::endOfFreebusyPeriod()
{
t_int32 i;
DateTime d(-1);
Julian_Duration du(-1, -1, -1, -1, -1, -1, -1);
nsCalDuration du(-1, -1, -1, -1, -1, -1, -1);
if (m_vPeriod != 0)
{
i = m_vPeriod->GetSize();

8
calendar/modules/core/ical/src/icalsrdr.cpp
Просмотреть файл

@ -42,7 +42,7 @@ ICalStringReader::ICalStringReader() {}
//---------------------------------------------------------------------
ICalStringReader::ICalStringReader(const char * string,
JulianUtility::MimeEncoding encoding)
nsCalUtility::MimeEncoding encoding)
: m_string(string), m_pos(0), m_mark(0)
{
m_length = strlen(m_string);
@ -62,15 +62,15 @@ t_int8 ICalStringReader::read(ErrorCode & status)
else
{
status = ZERO_ERROR;
if (m_Encoding == JulianUtility::MimeEncoding_7bit)
if (m_Encoding == nsCalUtility::MimeEncoding_7bit)
{
return m_string[m_pos++];
}
else
{
// for now only handles quoted-printable
PR_ASSERT(m_Encoding == JulianUtility::MimeEncoding_QuotedPrintable);
if (m_Encoding == JulianUtility::MimeEncoding_QuotedPrintable)
PR_ASSERT(m_Encoding == nsCalUtility::MimeEncoding_QuotedPrintable);
if (m_Encoding == nsCalUtility::MimeEncoding_QuotedPrintable)
{
if ((m_string[m_pos] == '=') && (m_length >= m_pos + 3))
{

12
calendar/modules/core/ical/src/jparser.cpp
Просмотреть файл

@ -62,23 +62,23 @@ JulianParser::JulianParser(ICalCAPIReader * reader,
//---------------------------------------------------------------------
JulianUtility::MimeEncoding
nsCalUtility::MimeEncoding
JulianParser::stringToEncodingType(UnicodeString & propVal)
{
if (propVal.compareIgnoreCase(JulianKeyword::Instance()->ms_s7bit) == 0)
{
return JulianUtility::MimeEncoding_7bit;
return nsCalUtility::MimeEncoding_7bit;
}
else if (propVal.compareIgnoreCase(JulianKeyword::Instance()->ms_sQUOTED_PRINTABLE) == 0)
{
return JulianUtility::MimeEncoding_QuotedPrintable;
return nsCalUtility::MimeEncoding_QuotedPrintable;
}
else if (propVal.compareIgnoreCase(JulianKeyword::Instance()->ms_sBase64) == 0)
{
return JulianUtility::MimeEncoding_Base64;
return nsCalUtility::MimeEncoding_Base64;
}
else
return JulianUtility::MimeEncoding_7bit;
return nsCalUtility::MimeEncoding_7bit;
}
//---------------------------------------------------------------------
@ -105,7 +105,7 @@ void JulianParser::ParseCalendars(ICalReader * reader,
JLog * log = 0;
ErrorCode status = ZERO_ERROR;
UnicodeString strLine, propName, propVal;
JulianUtility::MimeEncoding encoding = JulianUtility::MimeEncoding_7bit;
nsCalUtility::MimeEncoding encoding = nsCalUtility::MimeEncoding_7bit;
ICalCAPIReader * cr = (ICalCAPIReader *) reader;

12
calendar/modules/core/ical/src/nscal.cpp
Просмотреть файл

@ -335,7 +335,7 @@ NSCalendar::clone(JLog * initLog)
void
NSCalendar::parse(ICalReader * brFile,
UnicodeString & fileName,
JulianUtility::MimeEncoding encoding)
nsCalUtility::MimeEncoding encoding)
{
UnicodeString strLine, propName, propVal;
@ -1438,7 +1438,7 @@ NSCalendar::createVFreebusy(DateTime start, DateTime end)
vf->setDTEnd(end);
UnicodeString us = "vfbreply@hostname.com";
vf->setUID(JulianUIDRandomGenerator::generate(us));
vf->setUID(nsCalUIDRandomGenerator::generate(us));
vf->setSequence(0);
if (f != 0)
{
@ -1887,8 +1887,8 @@ NSCalendar::getTBEByComponentID(JulianPtrArray * out,
else
{
PR_ASSERT(d.isValid());
JulianRecurrenceID::RANGE aRange = JulianRecurrenceID::RANGE_NONE;
aRange = JulianRecurrenceID::stringToRange(sModifier);
nsCalRecurrenceID::RANGE aRange = nsCalRecurrenceID::RANGE_NONE;
aRange = nsCalRecurrenceID::stringToRange(sModifier);
DateTime icrid;
for (i = 0; i < components->GetSize(); i++)
@ -1906,13 +1906,13 @@ NSCalendar::getTBEByComponentID(JulianPtrArray * out,
// always add exact match
out->Add(ic);
}
else if (aRange == JulianRecurrenceID::RANGE_THISANDPRIOR &&
else if (aRange == nsCalRecurrenceID::RANGE_THISANDPRIOR &&
icrid.beforeDateTime(d))
{
// also add if THISANDPRIOR and icrid < d
out->Add(ic);
}
else if (aRange == JulianRecurrenceID::RANGE_THISANDFUTURE &&
else if (aRange == nsCalRecurrenceID::RANGE_THISANDFUTURE &&
icrid.afterDateTime(d))
{
// also add if THISANDFUTURE and icrid > d

68
calendar/modules/core/ical/src/orgnzr.cpp
Просмотреть файл

@ -29,23 +29,23 @@
#include "uri.h"
//---------------------------------------------------------------------
const t_int32 JulianOrganizer::ms_cJulianOrganizerName = 'N';
const t_int32 JulianOrganizer::ms_cJulianOrganizerDir = 'l'; // 'el'
const t_int32 JulianOrganizer::ms_cJulianOrganizerSentBy = 's';
const t_int32 JulianOrganizer::ms_cJulianOrganizerCN = 'C';
const t_int32 JulianOrganizer::ms_cJulianOrganizerLanguage = 'm';
const t_int32 JulianOrganizer::ms_cJulianOrganizerDisplayName = 'z';
const t_int32 nsCalOrganizer::ms_cnsCalOrganizerName = 'N';
const t_int32 nsCalOrganizer::ms_cnsCalOrganizerDir = 'l'; // 'el'
const t_int32 nsCalOrganizer::ms_cnsCalOrganizerSentBy = 's';
const t_int32 nsCalOrganizer::ms_cnsCalOrganizerCN = 'C';
const t_int32 nsCalOrganizer::ms_cnsCalOrganizerLanguage = 'm';
const t_int32 nsCalOrganizer::ms_cnsCalOrganizerDisplayName = 'z';
//---------------------------------------------------------------------
JulianOrganizer::JulianOrganizer(JLog * initLog)
nsCalOrganizer::nsCalOrganizer(JLog * initLog)
: m_Log(initLog)
{
}
//---------------------------------------------------------------------
JulianOrganizer::JulianOrganizer(JulianOrganizer & that)
nsCalOrganizer::nsCalOrganizer(nsCalOrganizer & that)
{
m_CN = that.m_CN;
m_Language = that.m_Language;
@ -57,23 +57,23 @@ JulianOrganizer::JulianOrganizer(JulianOrganizer & that)
//---------------------------------------------------------------------
JulianOrganizer::~JulianOrganizer()
nsCalOrganizer::~nsCalOrganizer()
{
}
//---------------------------------------------------------------------
ICalProperty *
JulianOrganizer::clone(JLog * initLog)
nsCalOrganizer::clone(JLog * initLog)
{
m_Log = initLog;
//PR_ASSERT(m_Log != 0);
return (ICalProperty *) new JulianOrganizer(*this);
return (ICalProperty *) new nsCalOrganizer(*this);
}
//---------------------------------------------------------------------
void JulianOrganizer::parse(UnicodeString & propVal,
void nsCalOrganizer::parse(UnicodeString & propVal,
JulianPtrArray * parameters)
{
t_int32 i;
@ -98,7 +98,7 @@ void JulianOrganizer::parse(UnicodeString & propVal,
//---------------------------------------------------------------------
void JulianOrganizer::setParam(UnicodeString & paramName,
void nsCalOrganizer::setParam(UnicodeString & paramName,
UnicodeString & paramVal)
{
ErrorCode status = ZERO_ERROR;
@ -139,7 +139,7 @@ void JulianOrganizer::setParam(UnicodeString & paramName,
if (m_Log) m_Log->logError(JulianLogErrorMessage::Instance()->ms_iDuplicatedParameter,
JulianKeyword::Instance()->ms_sORGANIZER, paramName, 100);
}
JulianUtility::stripDoubleQuotes(paramVal); // double quote property
nsCalUtility::stripDoubleQuotes(paramVal); // double quote property
setSentBy(paramVal);
}
else if (JulianKeyword::Instance()->ms_ATOM_DIR == hashCode)
@ -149,7 +149,7 @@ void JulianOrganizer::setParam(UnicodeString & paramName,
if (m_Log) m_Log->logError(JulianLogErrorMessage::Instance()->ms_iDuplicatedParameter,
JulianKeyword::Instance()->ms_sORGANIZER, paramName, 100);
}
JulianUtility::stripDoubleQuotes(paramVal); // double quote property
nsCalUtility::stripDoubleQuotes(paramVal); // double quote property
setDir(paramVal);
}
else if (ICalProperty::IsXToken(paramName))
@ -167,7 +167,7 @@ void JulianOrganizer::setParam(UnicodeString & paramName,
//---------------------------------------------------------------------
UnicodeString & JulianOrganizer::toICALString(UnicodeString & out)
UnicodeString & nsCalOrganizer::toICALString(UnicodeString & out)
{
UnicodeString u;
return toICALString(u, out);
@ -175,7 +175,7 @@ UnicodeString & JulianOrganizer::toICALString(UnicodeString & out)
//---------------------------------------------------------------------
UnicodeString & JulianOrganizer::toICALString(UnicodeString & sProp,
UnicodeString & nsCalOrganizer::toICALString(UnicodeString & sProp,
UnicodeString & out)
{
out = "";
@ -195,7 +195,7 @@ UnicodeString & JulianOrganizer::toICALString(UnicodeString & sProp,
{
// double quote sent-by, dir
u = m_SentBy;
u = JulianUtility::addDoubleQuotes(u);
u = nsCalUtility::addDoubleQuotes(u);
out += ';'; out += JulianKeyword::Instance()->ms_sSENTBY;
out += '='; out += u;
}
@ -203,7 +203,7 @@ UnicodeString & JulianOrganizer::toICALString(UnicodeString & sProp,
{
// double quote sent-by, dir
u = m_Dir;
u = JulianUtility::addDoubleQuotes(u);
u = nsCalUtility::addDoubleQuotes(u);
out += ';'; out += JulianKeyword::Instance()->ms_sDIR;
out += '='; out += u;
}
@ -215,7 +215,7 @@ UnicodeString & JulianOrganizer::toICALString(UnicodeString & sProp,
//---------------------------------------------------------------------
UnicodeString & JulianOrganizer::toString(UnicodeString & out)
UnicodeString & nsCalOrganizer::toString(UnicodeString & out)
{
out = toString(JulianFormatString::Instance()->ms_OrganizerStrDefaultFmt, out);
return out;
@ -223,7 +223,7 @@ UnicodeString & JulianOrganizer::toString(UnicodeString & out)
//---------------------------------------------------------------------
UnicodeString & JulianOrganizer::toString(UnicodeString & strFmt,
UnicodeString & nsCalOrganizer::toString(UnicodeString & strFmt,
UnicodeString & out)
{
if (strFmt.size() == 0 &&
@ -272,23 +272,23 @@ UnicodeString & JulianOrganizer::toString(UnicodeString & strFmt,
//---------------------------------------------------------------------
UnicodeString JulianOrganizer::toStringChar(t_int32 c)
UnicodeString nsCalOrganizer::toStringChar(t_int32 c)
{
switch(c)
{
case ms_cJulianOrganizerName:
case ms_cnsCalOrganizerName:
return getName();
case ms_cJulianOrganizerDir:
case ms_cnsCalOrganizerDir:
return m_Dir;
case ms_cJulianOrganizerSentBy:
case ms_cnsCalOrganizerSentBy:
return m_SentBy;
case ms_cJulianOrganizerCN:
case ms_cnsCalOrganizerCN:
return m_CN;
case ms_cJulianOrganizerLanguage:
case ms_cnsCalOrganizerLanguage:
return m_Language;
case ms_cJulianOrganizerDisplayName:
case ms_cnsCalOrganizerDisplayName:
// return CN is CN != "", else
// return the JulianOrganizerName after the ':'
// return the nsCalOrganizerName after the ':'
if (m_CN.size() > 0)
return m_CN;
else
@ -310,7 +310,7 @@ UnicodeString JulianOrganizer::toStringChar(t_int32 c)
//---------------------------------------------------------------------
t_bool JulianOrganizer::isValid()
t_bool nsCalOrganizer::isValid()
{
/*
UnicodeString mailto;
@ -329,7 +329,7 @@ t_bool JulianOrganizer::isValid()
//---------------------------------------------------------------------
void *
JulianOrganizer::getValue() const
nsCalOrganizer::getValue() const
{
return (void *) &m_Name;
}
@ -337,7 +337,7 @@ JulianOrganizer::getValue() const
//---------------------------------------------------------------------
void
JulianOrganizer::setValue(void * value)
nsCalOrganizer::setValue(void * value)
{
PR_ASSERT(value != 0);
if (value != 0)
@ -348,7 +348,7 @@ JulianOrganizer::setValue(void * value)
//---------------------------------------------------------------------
void JulianOrganizer::setParameters(JulianPtrArray * parameters)
void nsCalOrganizer::setParameters(JulianPtrArray * parameters)
{
t_int32 i;
ICalParameter * param;
@ -366,7 +366,7 @@ void JulianOrganizer::setParameters(JulianPtrArray * parameters)
//---------------------------------------------------------------------
void JulianOrganizer::setName(UnicodeString sName)
void nsCalOrganizer::setName(UnicodeString sName)
{
m_Name = sName;
}

6
calendar/modules/core/ical/src/period.cpp
Просмотреть файл

@ -48,7 +48,7 @@ void Period::parse(UnicodeString & us)
UnicodeString sStart, sEnd;
t_int32 indexOfSlash = us.indexOf('/');
//DateTime start, end;
//Julian_Duration d;
//nsCalDuration d;
if (indexOfSlash < 0)
{
@ -199,7 +199,7 @@ void Period::setEnd(DateTime d)
//---------------------------------------------------------------------
void Period::setDuration(Julian_Duration d)
void Period::setDuration(nsCalDuration d)
{
m_Duration = d;
}
@ -532,7 +532,7 @@ t_bool Period::IsParseable(UnicodeString & s)
return FALSE;
if (!DateTime::IsParseable(sEnd))
{
Julian_Duration d(sEnd); //PR_ASSERT(d != 0);
nsCalDuration d(sEnd); //PR_ASSERT(d != 0);
if (!d.isValid())
return FALSE;
//delete d; d = 0; // nullify after delete

30
calendar/modules/core/ical/src/prprty.cpp
Просмотреть файл

@ -91,7 +91,7 @@ t_bool ICalProperty::CheckParams(JulianPtrArray * parameters,
ip = (ICalParameter *) parameters->GetAt(i);
u = ip->getParameterName(u);
if (!JulianUtility::checkRange(u.hashCode(), validParamNameRange,
if (!nsCalUtility::checkRange(u.hashCode(), validParamNameRange,
validParamNameRangeSize))
{
return FALSE;
@ -126,7 +126,7 @@ t_bool ICalProperty::CheckParamsWithValueRangeCheck(JulianPtrArray * parameters,
ip = (ICalParameter *) parameters->GetAt(i);
u = ip->getParameterName(u);
if (!JulianUtility::checkRange(u.hashCode(), validParamNameRange,
if (!nsCalUtility::checkRange(u.hashCode(), validParamNameRange,
validParamNameRangeSize))
{
return FALSE;
@ -135,7 +135,7 @@ t_bool ICalProperty::CheckParamsWithValueRangeCheck(JulianPtrArray * parameters,
if (JulianKeyword::Instance()->ms_ATOM_VALUE == u.hashCode())
{
u = ip->getParameterValue(u);
if (!JulianUtility::checkRange(u.hashCode(), validValueRange,
if (!nsCalUtility::checkRange(u.hashCode(), validValueRange,
validValueRangeSize))
{
if (!ICalProperty::IsXToken(u))
@ -146,7 +146,7 @@ t_bool ICalProperty::CheckParamsWithValueRangeCheck(JulianPtrArray * parameters,
else if (JulianKeyword::Instance()->ms_ATOM_ENCODING == u.hashCode())
{
u = ip->getParameterValue(u);
if (!JulianUtility::checkRange(u.hashCode(),
if (!nsCalUtility::checkRange(u.hashCode(),
JulianAtomRange::Instance()->ms_asEncodingRange,
JulianAtomRange::Instance()->ms_iEncodingRangeSize))
{
@ -158,7 +158,7 @@ t_bool ICalProperty::CheckParamsWithValueRangeCheck(JulianPtrArray * parameters,
else if (JulianKeyword::Instance()->ms_ATOM_RELTYPE == u.hashCode())
{
u = ip->getParameterValue(u);
if (!JulianUtility::checkRange(u.hashCode(),
if (!nsCalUtility::checkRange(u.hashCode(),
JulianAtomRange::Instance()->ms_asRelTypeRange,
JulianAtomRange::Instance()->ms_iRelTypeRangeSize))
{
@ -170,7 +170,7 @@ t_bool ICalProperty::CheckParamsWithValueRangeCheck(JulianPtrArray * parameters,
else if (JulianKeyword::Instance()->ms_ATOM_RELATED == u.hashCode())
{
u = ip->getParameterValue(u);
if (!JulianUtility::checkRange(u.hashCode(),
if (!nsCalUtility::checkRange(u.hashCode(),
JulianAtomRange::Instance()->ms_asRelatedRange,
JulianAtomRange::Instance()->ms_iRelatedRangeSize))
{
@ -190,7 +190,7 @@ t_bool ICalProperty::checkParam(UnicodeString & propName,
{
t_int32 hashCode = propName.hashCode();
if (JulianUtility::checkRange(hashCode,
if (nsCalUtility::checkRange(hashCode,
JulianAtomRange::Instance()->ms_asIrregularProperties,
JulianAtomRange::Instance()->ms_iIrregularPropertiesSize))
{
@ -206,7 +206,7 @@ t_bool ICalProperty::checkParam(UnicodeString & propName,
return FALSE;
// not a valid parameter for th
if (!JulianUtility::checkRange(pNHC,
if (!nsCalUtility::checkRange(pNHC,
JulianAtomRange::Instance()->ms_asParameterRange,
JulianAtomRange::Instance()->ms_iParameterRangeSize))
return TRUE;
@ -219,7 +219,7 @@ t_bool ICalProperty::checkParam(UnicodeString & propName,
// TODO: Check LANGUAGE later
if (JulianKeyword::Instance()->ms_ATOM_VALUE == pNHC)
{
if ((!JulianUtility::checkRange(pVHC,
if ((!nsCalUtility::checkRange(pVHC,
JulianAtomRange::Instance()->ms_asValueRange,
JulianAtomRange::Instance()->ms_iValueRangeSize))
&& (!IsXToken(paramVal)))
@ -227,7 +227,7 @@ t_bool ICalProperty::checkParam(UnicodeString & propName,
}
else if (JulianKeyword::Instance()->ms_ATOM_ENCODING == pNHC)
{
if ((!JulianUtility::checkRange(pVHC,
if ((!nsCalUtility::checkRange(pVHC,
JulianAtomRange::Instance()->ms_asEncodingRange,
JulianAtomRange::Instance()->ms_iEncodingRangeSize)) && (!IsXToken(paramVal)))
return TRUE;
@ -287,7 +287,7 @@ void ICalProperty::parsePropertyLine(UnicodeString & strLine,
{
outName = strLine.extractBetween(0, iColon, outName).toUpper();
//outName = strLine.extractBetween(0, iColon, outName);
//outName = JulianUtility::ToUpper(outName);
//outName = nsCalUtility::ToUpper(outName);
outVal = strLine.extractBetween(iColon + 1, lineLength, outVal);
}
@ -295,7 +295,7 @@ void ICalProperty::parsePropertyLine(UnicodeString & strLine,
{
outName = strLine.toUpper();
//outName = strLine;
//outName = JulianUtility::ToUpper(outName);
//outName = nsCalUtility::ToUpper(outName);
outVal = "";
}
@ -312,7 +312,7 @@ void ICalProperty::parsePropertyLine(UnicodeString & strLine,
outName = strLine.extractBetween(0, iIndex, u).toUpper();
//outName = strLine.extractBetween(0, iIndex, u);
//outName = JulianUtility::ToUpper(outName);
//outName = nsCalUtility::ToUpper(outName);
outVal = strLine.extractBetween(iColon + 1, lineLength, u);
}
@ -351,7 +351,7 @@ void ICalProperty::parsePropertyLine(UnicodeString & strLine,
{
paramName = u.extractBetween(0, u.size(), paramName).toUpper();
//paramName = u.extractBetween(0, u.size(), paramName);
//paramName = JulianUtility::ToUpper(paramName);
//paramName = nsCalUtility::ToUpper(paramName);
paramVal = "";
}
@ -359,7 +359,7 @@ void ICalProperty::parsePropertyLine(UnicodeString & strLine,
{
paramName = u.extractBetween(0, iEq, paramName).toUpper();
//paramName = u.extractBetween(0, u.size(), paramName);
//paramName = JulianUtility::ToUpper(paramName);
//paramName = nsCalUtility::ToUpper(paramName);
paramVal = u.extractBetween(iEq + 1, u.size(), paramVal);
}

2
calendar/modules/core/ical/src/prprtyfy.cpp
Просмотреть файл

@ -56,7 +56,7 @@ ICalPropertyFactory::Make(ICalProperty::PropertyTypes aType, void * value,
case ICalProperty::INTEGER:
return new IntegerProperty(*((t_int32 *) value), parameters);
case ICalProperty::DURATION:
return new DurationProperty(*((Julian_Duration *) value), parameters);
return new DurationProperty(*((nsCalDuration *) value), parameters);
case ICalProperty::PERIOD:
return 0;
//return new PeriodProperty((Period *) value, parameters);

68
calendar/modules/core/ical/src/rcrrence.cpp
Просмотреть файл

@ -185,7 +185,7 @@ const t_int32 Recurrence::ms_GenOrderLen = 6;
void Recurrence::init()
{
m_iType = JulianUtility::RT_NONE;
m_iType = nsCalUtility::RT_NONE;
m_Interval = 0;
m_iCount = ms_iUNSET;
m_iWkSt = Calendar::MONDAY;
@ -240,7 +240,7 @@ Recurrence::Recurrence()
//---------------------------------------------------------------------
#if 0
Recurrence::Recurrence(DateTime startDate, DateTime stopDate,
Julian_Duration * duration, UnicodeString & ruleString)
nsCalDuration * duration, UnicodeString & ruleString)
{
init();
m_StartDate = startDate;
@ -252,7 +252,7 @@ Recurrence::Recurrence(DateTime startDate, DateTime stopDate,
}
//---------------------------------------------------------------------
Recurrence::Recurrence(DateTime startDate, Julian_Duration * duration,
Recurrence::Recurrence(DateTime startDate, nsCalDuration * duration,
UnicodeString & ruleString)
{
init();
@ -461,7 +461,7 @@ Recurrence::parse(UnicodeString & s)
{
char * tcc = t.toCString("");
PR_ASSERT(tcc != 0);
m_iCount = JulianUtility::atot_int32(tcc, bParseError, tSize);
m_iCount = nsCalUtility::atot_int32(tcc, bParseError, tSize);
delete [] tcc; tcc = 0;
}
else if (JulianKeyword::Instance()->ms_ATOM_INTERVAL == atomParam)
@ -469,7 +469,7 @@ Recurrence::parse(UnicodeString & s)
// TODO: if duration allowed, parse duration, then it to interval
char * tcc = t.toCString("");
PR_ASSERT(tcc != 0);
tempInterval = JulianUtility::atot_int32(tcc, bParseError, tSize);
tempInterval = nsCalUtility::atot_int32(tcc, bParseError, tSize);
delete [] tcc; tcc = 0;
}
else if (JulianKeyword::Instance()->ms_ATOM_WKST == atomParam)
@ -591,13 +591,13 @@ Recurrence::parse(UnicodeString & s)
{
switch(m_iType)
{
case JulianUtility::RT_WEEKLY:
case nsCalUtility::RT_WEEKLY:
dg = (DateGenerator *) m_GntrVctr->GetAt(ms_iByDayWeeklyGntrIndex);
break;
case JulianUtility::RT_MONTHLY:
case nsCalUtility::RT_MONTHLY:
dg = (DateGenerator *) m_GntrVctr->GetAt(ms_iByDayMonthlyGntrIndex);
break;
case JulianUtility::RT_YEARLY:
case nsCalUtility::RT_YEARLY:
dg = (DateGenerator *) m_GntrVctr->GetAt(ms_iByDayYearlyGntrIndex);
break;
default:
@ -733,31 +733,31 @@ Recurrence::parse(UnicodeString & s)
void Recurrence::internalSetInterval(t_int32 i)
{
m_Interval = new Julian_Duration();
m_Interval = new nsCalDuration();
switch(m_iType)
{
case JulianUtility::RT_MINUTELY:
case nsCalUtility::RT_MINUTELY:
//m_Interval->setMinute(i);
m_Interval->set(0,0,0,0,i,0);
break;
case JulianUtility::RT_HOURLY:
case nsCalUtility::RT_HOURLY:
//m_Interval->setHour(i);
m_Interval->set(0,0,0,i,0,0);
break;
case JulianUtility::RT_DAILY:
case nsCalUtility::RT_DAILY:
//m_Interval->setDay(i);
m_Interval->set(0,0,i,0,0,0);
break;
case JulianUtility::RT_WEEKLY:
case nsCalUtility::RT_WEEKLY:
//m_Interval->setWeek(i);
m_Interval->set(i);
break;
case JulianUtility::RT_MONTHLY:
case nsCalUtility::RT_MONTHLY:
//m_Interval->setMonth(i);
m_Interval->set(0,i,0,0,0,0);
break;
case JulianUtility::RT_YEARLY:
case nsCalUtility::RT_YEARLY:
//m_Interval->setYear(i);
m_Interval->set(i,0,0,0,0,0);
break;
@ -1183,7 +1183,7 @@ Recurrence::unzip(t_int32 bound, JulianPtrArray * out, JLog * log,
}
}
if (m_iType == JulianUtility::RT_MONTHLY)
if (m_iType == nsCalUtility::RT_MONTHLY)
{
t_int32 interval = m_Interval->getMonth();
while (interval > 0)
@ -1285,16 +1285,16 @@ Recurrence::reset(DateTime & t, t_int32 type, t_int32 wkSt)
t_int32 temp = 0;
switch(type)
{
case JulianUtility::RT_YEARLY:
case nsCalUtility::RT_YEARLY:
t.add(Calendar::DAY_OF_YEAR, -t.get(Calendar::DAY_OF_YEAR) + 1);
break;
case JulianUtility::RT_MONTHLY:
case nsCalUtility::RT_MONTHLY:
t.add(Calendar::DAY_OF_MONTH, -t.get(Calendar::DAY_OF_MONTH) + 1);
break;
case JulianUtility::RT_WEEKLY:
case nsCalUtility::RT_WEEKLY:
t.moveTo(wkSt, -1, FALSE);
break;
case JulianUtility::RT_DAILY:
case nsCalUtility::RT_DAILY:
// this case is purposely empty. a daily rule can only contain a byhour,
// or a byminute tag. or it can have no tags. if it has a tag, then the
@ -1303,10 +1303,10 @@ Recurrence::reset(DateTime & t, t_int32 type, t_int32 wkSt)
// never be reached, since a defaultgenerator will be installed and will
//handle all of the work in one run.
break;
case JulianUtility::RT_HOURLY:
case nsCalUtility::RT_HOURLY:
t.set(Calendar::MINUTE, 0);
break;
case JulianUtility::RT_MINUTELY:
case nsCalUtility::RT_MINUTELY:
t.set(Calendar::SECOND, 0);
break;
}
@ -1326,7 +1326,7 @@ Recurrence::reset(DateTime & t, t_int32 type, t_int32 wkSt)
temp = ms_iByMinuteGntrIndex;
if (((DateGenerator *) (m_GntrVctr->GetAt(temp)))->active())
{
if (type != JulianUtility::RT_HOURLY)
if (type != nsCalUtility::RT_HOURLY)
t.set(Calendar::HOUR_OF_DAY, 0);
t.set(Calendar::MINUTE, 0);
}
@ -1586,12 +1586,12 @@ t_int32 Recurrence::stringToType(UnicodeString & s, t_bool & bParseError)
if (s.size() > 0)
{
if (s == JulianKeyword::Instance()->ms_sMINUTELY) iType = JulianUtility::RT_MINUTELY;
else if (s == JulianKeyword::Instance()->ms_sHOURLY) iType = JulianUtility::RT_HOURLY;
else if (s == JulianKeyword::Instance()->ms_sDAILY) iType = JulianUtility::RT_DAILY;
else if (s == JulianKeyword::Instance()->ms_sWEEKLY) iType = JulianUtility::RT_WEEKLY;
else if (s == JulianKeyword::Instance()->ms_sMONTHLY) iType = JulianUtility::RT_MONTHLY;
else if (s == JulianKeyword::Instance()->ms_sYEARLY) iType = JulianUtility::RT_YEARLY;
if (s == JulianKeyword::Instance()->ms_sMINUTELY) iType = nsCalUtility::RT_MINUTELY;
else if (s == JulianKeyword::Instance()->ms_sHOURLY) iType = nsCalUtility::RT_HOURLY;
else if (s == JulianKeyword::Instance()->ms_sDAILY) iType = nsCalUtility::RT_DAILY;
else if (s == JulianKeyword::Instance()->ms_sWEEKLY) iType = nsCalUtility::RT_WEEKLY;
else if (s == JulianKeyword::Instance()->ms_sMONTHLY) iType = nsCalUtility::RT_MONTHLY;
else if (s == JulianKeyword::Instance()->ms_sYEARLY) iType = nsCalUtility::RT_YEARLY;
else bParseError = TRUE;
}
else
@ -1640,7 +1640,7 @@ Recurrence::verifyIntList(JulianPtrArray * v, t_int32 lowerBound,
}
char * kcc = s.extractBetween(startIndex, s.size(), into).toCString("");
PR_ASSERT(kcc != 0);
k = JulianUtility::atot_int32(kcc,
k = nsCalUtility::atot_int32(kcc,
bParseError, (s.size() - startIndex));
delete [] kcc; kcc = 0;
@ -1649,7 +1649,7 @@ Recurrence::verifyIntList(JulianPtrArray * v, t_int32 lowerBound,
{
k = 0 - k;
}
//k = JulianUtility::atot_int32(s.toCString(""), bParseError, s.size());
//k = nsCalUtility::atot_int32(s.toCString(""), bParseError, s.size());
if (bZero && k == 0)
bParseError = TRUE;
@ -1693,12 +1693,12 @@ Recurrence::createByDayList(JulianPtrArray * v, t_int32 type,
createByDayListHelper(*sPtr, day, modifier, bParseError);
// if modifier out of bounds, set bParseError to TRUE
if ((type == JulianUtility::RT_YEARLY) &&
if ((type == nsCalUtility::RT_YEARLY) &&
(modifier < -53 || modifier > 53))
{
bParseError = TRUE;
}
else if ((type == JulianUtility::RT_MONTHLY) &&
else if ((type == nsCalUtility::RT_MONTHLY) &&
(modifier < -5 || modifier > 5))
{
bParseError = TRUE;
@ -1740,7 +1740,7 @@ void Recurrence::createByDayListHelper(UnicodeString & in,
in.size() - 2, into).toCString("");
PR_ASSERT(incc != 0);
modifier =
JulianUtility::atot_int32(incc,
nsCalUtility::atot_int32(incc,
bParseError, (in.size() - 2 - startIndex));
delete [] incc; incc = 0;
// if Minus sign, set to inverse

46
calendar/modules/core/ical/src/recid.cpp
Просмотреть файл

@ -29,15 +29,15 @@
// private never use
#if 0
JulianRecurrenceID::JulianRecurrenceID()
nsCalRecurrenceID::nsCalRecurrenceID()
{
PR_ASSERT(FALSE);
}
#endif
//---------------------------------------------------------------------
JulianRecurrenceID::JulianRecurrenceID(JLog * initLog)
: m_DateTime(-1), m_Range(JulianRecurrenceID::RANGE_NONE),
nsCalRecurrenceID::nsCalRecurrenceID(JLog * initLog)
: m_DateTime(-1), m_Range(nsCalRecurrenceID::RANGE_NONE),
m_Log(initLog)
{
//PR_ASSERT(initLog != 0);
@ -45,7 +45,7 @@ JulianRecurrenceID::JulianRecurrenceID(JLog * initLog)
//---------------------------------------------------------------------
JulianRecurrenceID::JulianRecurrenceID(JulianRecurrenceID & that)
nsCalRecurrenceID::nsCalRecurrenceID(nsCalRecurrenceID & that)
: m_Range(that.m_Range)
{
m_DateTime = that.m_DateTime;
@ -53,7 +53,7 @@ JulianRecurrenceID::JulianRecurrenceID(JulianRecurrenceID & that)
//---------------------------------------------------------------------
JulianRecurrenceID::JulianRecurrenceID(DateTime datetime,
nsCalRecurrenceID::nsCalRecurrenceID(DateTime datetime,
JLog * initLog,
RANGE range)
@ -65,20 +65,20 @@ JulianRecurrenceID::JulianRecurrenceID(DateTime datetime,
//---------------------------------------------------------------------
JulianRecurrenceID::~JulianRecurrenceID() {}
nsCalRecurrenceID::~nsCalRecurrenceID() {}
//---------------------------------------------------------------------
ICalProperty * JulianRecurrenceID::clone(JLog * initLog)
ICalProperty * nsCalRecurrenceID::clone(JLog * initLog)
{
m_Log = initLog;
//PR_ASSERT(m_Log != 0);
return new JulianRecurrenceID(*this);
return new nsCalRecurrenceID(*this);
}
//---------------------------------------------------------------------
void JulianRecurrenceID::setParameters(JulianPtrArray * parameters)
void nsCalRecurrenceID::setParameters(JulianPtrArray * parameters)
{
t_int32 i;
ICalParameter * ip;
@ -96,7 +96,7 @@ void JulianRecurrenceID::setParameters(JulianPtrArray * parameters)
//---------------------------------------------------------------------
void JulianRecurrenceID::setParam(UnicodeString & paramName, UnicodeString & paramVal)
void nsCalRecurrenceID::setParam(UnicodeString & paramName, UnicodeString & paramVal)
{
t_int32 i;
if (paramName.size() == 0)
@ -110,7 +110,7 @@ void JulianRecurrenceID::setParam(UnicodeString & paramName, UnicodeString & par
if (JulianKeyword::Instance()->ms_ATOM_RANGE == hashCode)
{
i = JulianRecurrenceID::stringToRange(paramVal);
i = nsCalRecurrenceID::stringToRange(paramVal);
if (i < 0)
{
if (m_Log) m_Log->logError(JulianLogErrorMessage::Instance()->ms_iInvalidParameterValue,
@ -123,7 +123,7 @@ void JulianRecurrenceID::setParam(UnicodeString & paramName, UnicodeString & par
if (m_Log) m_Log->logError(JulianLogErrorMessage::Instance()->ms_iDuplicatedParameter,
JulianKeyword::Instance()->ms_sRECURRENCEID, paramName, 100);
}
setRange((JulianRecurrenceID::RANGE) i);
setRange((nsCalRecurrenceID::RANGE) i);
}
}
else if (ICalProperty::IsXToken(paramName))
@ -142,7 +142,7 @@ void JulianRecurrenceID::setParam(UnicodeString & paramName, UnicodeString & par
//---------------------------------------------------------------------
t_bool JulianRecurrenceID::isValid()
t_bool nsCalRecurrenceID::isValid()
{
return m_DateTime.isValid();
}
@ -150,7 +150,7 @@ t_bool JulianRecurrenceID::isValid()
//---------------------------------------------------------------------
UnicodeString &
JulianRecurrenceID::toString(UnicodeString & strFmt, UnicodeString & out)
nsCalRecurrenceID::toString(UnicodeString & strFmt, UnicodeString & out)
{
// NOTE: Remove later
if (strFmt.size() > 0) {}
@ -161,7 +161,7 @@ JulianRecurrenceID::toString(UnicodeString & strFmt, UnicodeString & out)
//---------------------------------------------------------------------
void
JulianRecurrenceID::setValue(void * value)
nsCalRecurrenceID::setValue(void * value)
{
PR_ASSERT(value != 0);
if (value != 0)
@ -173,7 +173,7 @@ JulianRecurrenceID::setValue(void * value)
//---------------------------------------------------------------------
void *
JulianRecurrenceID::getValue() const
nsCalRecurrenceID::getValue() const
{
return (void *) &m_DateTime;
}
@ -181,7 +181,7 @@ JulianRecurrenceID::getValue() const
//---------------------------------------------------------------------
UnicodeString &
JulianRecurrenceID::toString(UnicodeString & out)
nsCalRecurrenceID::toString(UnicodeString & out)
{
UnicodeString u;
out = "";
@ -197,11 +197,11 @@ JulianRecurrenceID::toString(UnicodeString & out)
//---------------------------------------------------------------------
UnicodeString &
JulianRecurrenceID::toICALString(UnicodeString & sProp, UnicodeString & out)
nsCalRecurrenceID::toICALString(UnicodeString & sProp, UnicodeString & out)
{
out = "";
out += sProp;
if (m_Range != JulianRecurrenceID::RANGE_NONE)
if (m_Range != nsCalRecurrenceID::RANGE_NONE)
{
UnicodeString u;
out += ';';
@ -218,7 +218,7 @@ JulianRecurrenceID::toICALString(UnicodeString & sProp, UnicodeString & out)
//---------------------------------------------------------------------
UnicodeString &
JulianRecurrenceID::toICALString(UnicodeString & out)
nsCalRecurrenceID::toICALString(UnicodeString & out)
{
UnicodeString u;
return toICALString(u, out);
@ -226,8 +226,8 @@ JulianRecurrenceID::toICALString(UnicodeString & out)
//---------------------------------------------------------------------
JulianRecurrenceID::RANGE
JulianRecurrenceID::stringToRange(UnicodeString & sRange)
nsCalRecurrenceID::RANGE
nsCalRecurrenceID::stringToRange(UnicodeString & sRange)
{
t_int32 hashCode = sRange.hashCode();
@ -241,7 +241,7 @@ JulianRecurrenceID::stringToRange(UnicodeString & sRange)
//---------------------------------------------------------------------
UnicodeString &
JulianRecurrenceID::rangeToString(JulianRecurrenceID::RANGE range,
nsCalRecurrenceID::rangeToString(nsCalRecurrenceID::RANGE range,
UnicodeString & out)
{
out = "";

8
calendar/modules/core/ical/src/tmbevent.cpp
Просмотреть файл

@ -634,7 +634,7 @@ TimeBasedEvent::parseType(UnicodeString & sType, ICalReader * brFile,
UnicodeString & sMethod,
UnicodeString & parseStatus,
JulianPtrArray * vTimeZones, t_bool bIgnoreBeginError,
JulianUtility::MimeEncoding encoding)
nsCalUtility::MimeEncoding encoding)
{
t_bool bNewEvent = FALSE;
t_bool bNextAlarm = FALSE;
@ -1247,7 +1247,7 @@ void TimeBasedEvent::storeSequence(UnicodeString & strLine, UnicodeString & prop
char * pcc = propVal.toCString("");
PR_ASSERT(pcc != 0);
i = JulianUtility::atot_int32(pcc, bParseError, propVal.size());
i = nsCalUtility::atot_int32(pcc, bParseError, propVal.size());
delete [] pcc; pcc = 0;
if (getSequenceProperty() != 0)
@ -2429,7 +2429,7 @@ void TimeBasedEvent::setOrganizer(UnicodeString s, JulianPtrArray * parameters)
//m_Organizer = ICalPropertyFactory::Make(ICalProperty::TEXT,
// (void *) &s, parameters);
m_Organizer = (ICalProperty *) new JulianOrganizer(m_Log);
m_Organizer = (ICalProperty *) new nsCalOrganizer(m_Log);
PR_ASSERT(m_Organizer != 0);
if (m_Organizer != 0)
{
@ -2460,7 +2460,7 @@ void TimeBasedEvent::setRecurrenceID(DateTime s, JulianPtrArray * parameters)
{
if (m_RecurrenceID == 0)
{
m_RecurrenceID = (ICalProperty *) new JulianRecurrenceID(s, m_Log);
m_RecurrenceID = (ICalProperty *) new nsCalRecurrenceID(s, m_Log);
PR_ASSERT(m_RecurrenceID != 0);
if (m_RecurrenceID != 0)
{

8
calendar/modules/core/ical/src/tzpart.cpp
Просмотреть файл

@ -182,7 +182,7 @@ UnicodeString &
TZPart::parse(ICalReader * brFile, UnicodeString & sType,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones,
t_bool bIgnoreBeginError,
JulianUtility::MimeEncoding encoding)
nsCalUtility::MimeEncoding encoding)
{
UnicodeString strLine, propName, propVal;
JulianPtrArray * parameters = new JulianPtrArray();
@ -675,7 +675,7 @@ t_bool TZPart::parseRRule()
// since month is 0-based, must subtract 1
char * pVcc = pV.toCString("");
PR_ASSERT(pVcc != 0);
m_StartMonth = JulianUtility::atot_int32(pVcc, bParseError, pV.size()) - 1;
m_StartMonth = nsCalUtility::atot_int32(pVcc, bParseError, pV.size()) - 1;
delete [] pVcc; pVcc = 0;
}
else if (pN.compareIgnoreCase(JulianKeyword::Instance()->ms_sBYDAY) == 0)
@ -685,7 +685,7 @@ t_bool TZPart::parseRRule()
// positive week
char * pVcc = pV.toCString("");
PR_ASSERT(pVcc != 0);
m_StartWeek = JulianUtility::atot_int32(pVcc, bParseError, 1);
m_StartWeek = nsCalUtility::atot_int32(pVcc, bParseError, 1);
delete [] pVcc; pVcc = 0;
m_StartDay = Recurrence::stringToDay(pV.extract(1, 2, s), bParseError);
}
@ -695,7 +695,7 @@ t_bool TZPart::parseRRule()
char * pVcc = pV.toCString("");
PR_ASSERT(pVcc != 0);
m_StartWeek = JulianUtility::atot_int32(pVcc + 1, bParseError, 1); // (always len = 1)
m_StartWeek = nsCalUtility::atot_int32(pVcc + 1, bParseError, 1); // (always len = 1)
delete [] pVcc; pVcc = 0;
m_StartDay = Recurrence::stringToDay(pV.extract(2, 2, s), bParseError); // SU, MO, TU, etc. (always len = 2)

28
calendar/modules/core/ical/src/valarm.cpp
Просмотреть файл

@ -167,7 +167,7 @@ UnicodeString &
VAlarm::parse(ICalReader * brFile, UnicodeString & sType,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones,
t_bool bIgnoreBeginError,
JulianUtility::MimeEncoding encoding)
nsCalUtility::MimeEncoding encoding)
{
UnicodeString strLine, propName, propVal;
JulianPtrArray * parameters = new JulianPtrArray();
@ -373,7 +373,7 @@ void VAlarm::storeDuration(UnicodeString & strLine, UnicodeString & propVal,
JulianKeyword::Instance()->ms_sVALARM,
JulianKeyword::Instance()->ms_sDURATION, 100);
}
Julian_Duration d(propVal);
nsCalDuration d(propVal);
setDuration(d, parameters);
}
//---------------------------------------------------------------------
@ -393,7 +393,7 @@ void VAlarm::storeRepeat(UnicodeString & strLine, UnicodeString & propVal,
char * pcc = propVal.toCString("");
PR_ASSERT(pcc != 0);
i = JulianUtility::atot_int32(pcc, bParseError, propVal.size());
i = nsCalUtility::atot_int32(pcc, bParseError, propVal.size());
delete [] pcc; pcc = 0;
if (getRepeatProperty() != 0)
@ -472,7 +472,7 @@ void VAlarm::storeTrigger(UnicodeString & strLine, UnicodeString & propVal,
}
else
{
Julian_Duration d(propVal);
nsCalDuration d(propVal);
setTriggerAsDuration(d, parameters);
}
}
@ -795,8 +795,8 @@ UnicodeString & VAlarm::actionToString(VAlarm::ACTION action, UnicodeString & ou
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
///Julian_Duration
void VAlarm::setDuration(Julian_Duration s, JulianPtrArray * parameters)
///nsCalDuration
void VAlarm::setDuration(nsCalDuration s, JulianPtrArray * parameters)
{
if (m_Duration == 0)
m_Duration = ICalPropertyFactory::Make(ICalProperty::DURATION,
@ -807,20 +807,20 @@ void VAlarm::setDuration(Julian_Duration s, JulianPtrArray * parameters)
m_Duration->setParameters(parameters);
}
}
Julian_Duration VAlarm::getDuration() const
nsCalDuration VAlarm::getDuration() const
{
Julian_Duration d; d.set(-1,-1,-1,-1,-1,-1);
nsCalDuration d; d.set(-1,-1,-1,-1,-1,-1);
if (m_Duration == 0)
return d; // return 0;
else
{
d = *((Julian_Duration *) m_Duration->getValue());
d = *((nsCalDuration *) m_Duration->getValue());
return d;
}
}
//---------------------------------------------------------------------
///Trigger
void VAlarm::setTriggerAsDuration(Julian_Duration s, JulianPtrArray * parameters)
void VAlarm::setTriggerAsDuration(nsCalDuration s, JulianPtrArray * parameters)
{
if (m_Trigger == 0)
m_Trigger = ICalPropertyFactory::Make(ICalProperty::DURATION,
@ -831,14 +831,14 @@ void VAlarm::setTriggerAsDuration(Julian_Duration s, JulianPtrArray * parameters
m_Trigger->setParameters(parameters);
}
}
Julian_Duration VAlarm::getTriggerAsDuration() const
nsCalDuration VAlarm::getTriggerAsDuration() const
{
Julian_Duration d; d.set(-1,-1,-1,-1,-1,-1);
nsCalDuration d; d.set(-1,-1,-1,-1,-1,-1);
if (m_Trigger == 0)
return d; // return 0;
else
{
d = *((Julian_Duration *) m_Trigger->getValue());
d = *((nsCalDuration *) m_Trigger->getValue());
return d;
}
}
@ -847,7 +847,7 @@ DateTime VAlarm::getTriggerAsDateTime(DateTime start) const
DateTime d;
if (m_Trigger != 0)
{
Julian_Duration du = getTriggerAsDuration();
nsCalDuration du = getTriggerAsDuration();
start.add(du);
d = start;
}

12
calendar/modules/core/ical/src/vevent.cpp
Просмотреть файл

@ -153,7 +153,7 @@ VEvent::~VEvent()
UnicodeString &
VEvent::parse(ICalReader * brFile, UnicodeString & sMethod,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones,
t_bool bIgnoreBeginError, JulianUtility::MimeEncoding encoding)
t_bool bIgnoreBeginError, nsCalUtility::MimeEncoding encoding)
{
UnicodeString u = JulianKeyword::Instance()->ms_sVEVENT;
return parseType(u, brFile, sMethod, parseStatus, vTimeZones, bIgnoreBeginError, encoding);
@ -356,7 +356,7 @@ void VEvent::storeDuration(UnicodeString & strLine, UnicodeString & propVal,
//Duration d(propVal);
if (m_TempDuration == 0)
{
m_TempDuration = new Julian_Duration(propVal);
m_TempDuration = new nsCalDuration(propVal);
PR_ASSERT(m_TempDuration != 0);
}
else
@ -421,7 +421,7 @@ void VEvent::storePriority(UnicodeString & strLine, UnicodeString & propVal,
char * pcc = propVal.toCString("");
PR_ASSERT(pcc != 0);
i = JulianUtility::atot_int32(pcc, bParseError, propVal.size());
i = nsCalUtility::atot_int32(pcc, bParseError, propVal.size());
delete [] pcc; pcc = 0;
if (getPriorityProperty() != 0)
{
@ -949,7 +949,7 @@ DateTime VEvent::getDTEnd() const
}
//---------------------------------------------------------------------
///Duration
void VEvent::setDuration(Julian_Duration s, JulianPtrArray * parameters)
void VEvent::setDuration(nsCalDuration s, JulianPtrArray * parameters)
{
/*
if (m_Duration == 0)
@ -973,7 +973,7 @@ void VEvent::setDuration(Julian_Duration s, JulianPtrArray * parameters)
end.add(s);
setDTEnd(end);
}
Julian_Duration VEvent::getDuration() const
nsCalDuration VEvent::getDuration() const
{
/*
Duration d; d.setMonth(-1);
@ -985,7 +985,7 @@ Julian_Duration VEvent::getDuration() const
return d;
}
*/
Julian_Duration duration;
nsCalDuration duration;
DateTime start, end;
start = getDTStart();
end = getDTEnd();

20
calendar/modules/core/ical/src/vfrbsy.cpp
Просмотреть файл

@ -550,7 +550,7 @@ VFreebusy::~VFreebusy()
UnicodeString &
VFreebusy::parse(ICalReader * brFile, UnicodeString & method,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones,
t_bool bIgnoreBeginError, JulianUtility::MimeEncoding encoding)
t_bool bIgnoreBeginError, nsCalUtility::MimeEncoding encoding)
{
parseStatus = JulianKeyword::Instance()->ms_sOK;
UnicodeString strLine, propName, propVal;
@ -790,7 +790,7 @@ void VFreebusy::storeDuration(UnicodeString & strLine, UnicodeString & propVal,
//Duration d(propVal);
if (m_TempDuration == 0)
{
m_TempDuration = new Julian_Duration(propVal);
m_TempDuration = new nsCalDuration(propVal);
PR_ASSERT(m_TempDuration != 0);
}
else
@ -982,7 +982,7 @@ void VFreebusy::storeSequence(UnicodeString & strLine, UnicodeString & propVal,
char * pcc = propVal.toCString("");
PR_ASSERT(pcc != 0);
i = JulianUtility::atot_int32(pcc, bParseError, propVal.size());
i = nsCalUtility::atot_int32(pcc, bParseError, propVal.size());
delete [] pcc; pcc = 0;
if (getSequenceProperty() != 0)
{
@ -1657,8 +1657,8 @@ DateTime VFreebusy::getDTEnd() const
#endif
}
//---------------------------------------------------------------------
///Julian_Duration
void VFreebusy::setDuration(Julian_Duration s, JulianPtrArray * parameters)
///nsCalDuration
void VFreebusy::setDuration(nsCalDuration s, JulianPtrArray * parameters)
{
/*
if (m_Duration == 0)
@ -1681,19 +1681,19 @@ void VFreebusy::setDuration(Julian_Duration s, JulianPtrArray * parameters)
end.add(s);
setDTEnd(end);
}
Julian_Duration VFreebusy::getDuration() const
nsCalDuration VFreebusy::getDuration() const
{
/*
Julian_Duration d; d.set(-1,-1,-1,-1,-1,-1);
nsCalDuration d; d.set(-1,-1,-1,-1,-1,-1);
if (m_Duration == 0)
return d; // return 0;
else
{
d = *((Julian_Duration *) m_Duration->getValue());
d = *((nsCalDuration *) m_Duration->getValue());
return d;
}
*/
Julian_Duration duration;
nsCalDuration duration;
DateTime start, end;
start = getDTStart();
end = getDTEnd();
@ -1852,7 +1852,7 @@ void VFreebusy::setOrganizer(UnicodeString s, JulianPtrArray * parameters)
//m_Organizer = ICalPropertyFactory::Make(ICalProperty::TEXT,
// (void *) &s, parameters);
m_Organizer = (ICalProperty *) new JulianOrganizer(m_Log);
m_Organizer = (ICalProperty *) new nsCalOrganizer(m_Log);
PR_ASSERT(m_Organizer != 0);
m_Organizer->setValue((void *) &s);
m_Organizer->setParameters(parameters);

2
calendar/modules/core/ical/src/vjournal.cpp
Просмотреть файл

@ -83,7 +83,7 @@ VJournal::~VJournal()
UnicodeString &
VJournal::parse(ICalReader * brFile, UnicodeString & sMethod,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones,
t_bool bIgnoreBeginError, JulianUtility::MimeEncoding encoding)
t_bool bIgnoreBeginError, nsCalUtility::MimeEncoding encoding)
{
UnicodeString u = JulianKeyword::Instance()->ms_sVJOURNAL;
return parseType(u, brFile, sMethod, parseStatus, vTimeZones, bIgnoreBeginError, encoding);

2
calendar/modules/core/ical/src/vtimezne.cpp
Просмотреть файл

@ -151,7 +151,7 @@ VTimeZone::~VTimeZone()
UnicodeString &
VTimeZone::parse(ICalReader * brFile, UnicodeString & sType,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones,
t_bool bIgnoreBeginError, JulianUtility::MimeEncoding encoding)
t_bool bIgnoreBeginError, nsCalUtility::MimeEncoding encoding)
{
UnicodeString strLine, propName, propVal;
parseStatus = JulianKeyword::Instance()->ms_sOK;

22
calendar/modules/core/ical/src/vtodo.cpp
Просмотреть файл

@ -172,7 +172,7 @@ VTodo::~VTodo()
UnicodeString &
VTodo::parse(ICalReader * brFile, UnicodeString & sMethod,
UnicodeString & parseStatus, JulianPtrArray * vTimeZones,
t_bool bIgnoreBeginError, JulianUtility::MimeEncoding encoding)
t_bool bIgnoreBeginError, nsCalUtility::MimeEncoding encoding)
{
UnicodeString u = JulianKeyword::Instance()->ms_sVTODO;
return parseType(u, brFile, sMethod, parseStatus, vTimeZones, bIgnoreBeginError, encoding);
@ -334,10 +334,10 @@ void VTodo::storeDuration(UnicodeString & strLine, UnicodeString & propVal,
JulianKeyword::Instance()->ms_sVTODO,
JulianKeyword::Instance()->ms_sDURATION, 100);
}
//Julian_Duration d(propVal);
//nsCalDuration d(propVal);
if (m_TempDuration == 0)
{
m_TempDuration = new Julian_Duration(propVal);
m_TempDuration = new nsCalDuration(propVal);
PR_ASSERT(m_TempDuration != 0);
}
else
@ -402,7 +402,7 @@ void VTodo::storePercentComplete(UnicodeString & strLine, UnicodeString & propVa
char * pcc = propVal.toCString("");
PR_ASSERT(pcc != 0);
i = JulianUtility::atot_int32(pcc, bParseError, propVal.size());
i = nsCalUtility::atot_int32(pcc, bParseError, propVal.size());
delete [] pcc; pcc = 0;
if (getPercentCompleteProperty() != 0)
{
@ -446,7 +446,7 @@ void VTodo::storePriority(UnicodeString & strLine, UnicodeString & propVal,
char * pcc = propVal.toCString("");
PR_ASSERT(pcc != 0);
i = JulianUtility::atot_int32(pcc, bParseError, propVal.size());
i = nsCalUtility::atot_int32(pcc, bParseError, propVal.size());
delete [] pcc; pcc = 0;
if (getPriorityProperty() != 0)
{
@ -981,8 +981,8 @@ DateTime VTodo::getDue() const
#endif
}
//---------------------------------------------------------------------
///Julian_Duration
void VTodo::setDuration(Julian_Duration s, JulianPtrArray * parameters)
///nsCalDuration
void VTodo::setDuration(nsCalDuration s, JulianPtrArray * parameters)
{
/*
if (m_Duration == 0)
@ -1006,19 +1006,19 @@ void VTodo::setDuration(Julian_Duration s, JulianPtrArray * parameters)
due.add(s);
setDue(due);
}
Julian_Duration VTodo::getDuration() const
nsCalDuration VTodo::getDuration() const
{
/*
Julian_Duration d; d.setMonth(-1);
nsCalDuration d; d.setMonth(-1);
if (m_Duration == 0)
return d; // return 0;
else
{
d = *((Julian_Duration *) m_Duration->getValue());
d = *((nsCalDuration *) m_Duration->getValue());
return d;
}
*/
Julian_Duration duration;
nsCalDuration duration;
DateTime start, due;
start = getDTStart();
due = getDue();