Qtopia library API Documentation
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files Todo

event.cpp

/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "event.h"
#include "qfiledirect_p.h"
#include <qtopia/timeconversion.h>
#include <qtopia/stringutil.h>
#include <qtopia/private/recordfields.h>
#include <qbuffer.h>
#include <time.h>
#include "vobject_p.h"

#include <stdio.h>

using namespace Qtopia;

static void write( QString& buf, const Event::RepeatPattern &r )
{
    buf += " rtype=\"";
    switch ( r.type ) {
    case Event::Daily:
        buf += "Daily";
        break;
    case Event::Weekly:
        buf += "Weekly";
        break;
    case Event::MonthlyDay:
        buf += "MonthlyDay";
        break;
    case Event::MonthlyDate:
        buf += "MonthlyDate";
        break;
    case Event::Yearly:
        buf += "Yearly";
        break;
    default:
        buf += "NoRepeat";
        break;
    }
    buf += "\"";
    if ( r.days > 0 )
    buf += " rweekdays=\"" + QString::number( static_cast<int>( r.days ) ) + "\"";
    if ( r.position != 0 )
    buf += " rposition=\"" + QString::number( r.position ) + "\"";

    buf += " rfreq=\"" + QString::number( r.frequency ) + "\"";
    buf += " rhasenddate=\"" + QString::number( static_cast<int>( r.hasEndDate ) ) + "\"";
     if ( r.hasEndDate )
    buf += " enddt=\""
           + QString::number( r.endDateUTC ? r.endDateUTC : time( 0 ) )
           + "\"";
    buf += " created=\"" + QString::number( r.createTime ) + "\"";
}

Qtopia::UidGen Event::sUidGen( Qtopia::UidGen::Qtopia );

Event::Event() : Record()
{
    startUTC = endUTC = time( 0 );
    typ = Normal;
    hAlarm = FALSE;
    hRepeat = FALSE;
    aMinutes = 0;
    aSound = Silent;
    pattern.type = NoRepeat;
    pattern.frequency = -1;
}

Event::Event( const QMap<int, QString> &map )
{
    setDescription( map[DatebookDescription] );
    setLocation( map[Location] );
    setCategories( idsFromString( map[DatebookCategory] ) );
    setTimeZone( map[TimeZone] );
    setNotes( map[Note] );
    setStart( TimeConversion::fromUTC( map[StartDateTime].toUInt() ) );
    setEnd( TimeConversion::fromUTC( map[EndDateTime].toUInt() ) );
    setType( (Event::Type) map[DatebookType].toInt() );
    setAlarm( ( map[HasAlarm] == "1" ? TRUE : FALSE ), map[AlarmTime].toInt(), (Event::SoundTypeChoice)map[SoundType].toInt() );
    Event::RepeatPattern p;
    p.type = (Event::RepeatType) map[ RepeatPatternType ].toInt();
    p.frequency = map[ RepeatPatternFrequency ].toInt();
    p.position = map[ RepeatPatternPosition ].toInt();
    p.days = map[ RepeatPatternDays ].toInt();
    p.hasEndDate = map[ RepeatPatternHasEndDate ].toInt();
    p.endDateUTC = map[ RepeatPatternEndDate ].toUInt();
    setRepeat( p );

    setUid( map[ DatebookUid ].toInt() );
}

Event::~Event()
{
}

int Event::week( const QDate& date )
{
    // Calculates the week this date is in within that
    // month. Equals the "row" is is in in the month view
    int week = 1;
    QDate tmp( date.year(), date.month(), 1 );

    if ( date.dayOfWeek() < tmp.dayOfWeek() )
    ++week;

    week += ( date.day() - 1 ) / 7;
    return week;
}

int Event::occurrence( const QDate& date )
{
    // calculates the number of occurrances of this day of the
    // week till the given date (e.g 3rd Wednesday of the month)
    return ( date.day() - 1 ) / 7 + 1;
}

int Event::dayOfWeek( char day )
{
    int dayOfWeek = 1;
    char i = Event::MON;
    while ( !( i & day ) && i <= Event::SUN ) {
    i <<= 1;
    ++dayOfWeek;
    }
    return dayOfWeek;
}

int Event::monthDiff( const QDate& first, const QDate& second )
{
    return ( second.year() - first.year() ) * 12 +
    second.month() - first.month();
}

QMap<int, QString> Event::toMap() const
{
    QMap<int, QString> m;

    if ( !description().isEmpty() )
    m.insert( DatebookDescription, description() );
    if ( !location().isEmpty() )
    m.insert ( Location, location() );
    if ( categories().count() )
    m.insert ( DatebookCategory, idsToString( categories() ) );
    if ( !timeZone().isEmpty() )
    m.insert ( TimeZone, timeZone() );
    if ( !notes().isEmpty() )
    m.insert ( Note, notes() );

    m.insert ( StartDateTime, QString::number( TimeConversion::toUTC( start() ) ) );
    m.insert ( EndDateTime, QString::number( TimeConversion::toUTC( end() ) ) );
    m.insert ( DatebookType, QString::number( (int)type() ) );
    m.insert ( HasAlarm, ( hasAlarm() ? "1" : "0" ) );
    m.insert ( SoundType, QString::number( (int)alarmSound() ) );
    m.insert ( AlarmTime, QString::number( alarmTime() ) );
    m.insert ( RepeatPatternType, QString::number( static_cast<int>( repeatPattern().type ) ) );
    m.insert ( RepeatPatternFrequency, QString::number( repeatPattern().frequency ) );
    m.insert ( RepeatPatternPosition, QString::number( repeatPattern().position ) );
    m.insert ( RepeatPatternDays, QString::number( repeatPattern().days ) );
    m.insert ( RepeatPatternHasEndDate, QString::number( static_cast<int>( repeatPattern().hasEndDate ) ) );
    m.insert ( RepeatPatternEndDate, QString::number( repeatPattern().endDateUTC ) );

    m.insert( DatebookUid, QString::number( uid()) );

    return m;
}

void Event::setRepeat( const RepeatPattern &p )
{
    setRepeat( p.type != NoRepeat, p );
}

void Event::setDescription( const QString &s )
{
    descript = s;
}

void Event::setLocation( const QString &s )
{
    locat = s;
}

// void Event::setCategory( const QString &s )
// {
//     categ = s;
// }

void Event::setType( Type t )
{
    typ = t;
}

void Event::setStart( const QDateTime &d )
{
    startUTC = TimeConversion::toUTC( d );
}

void Event::setStart( time_t time )
{
    startUTC = time;
}

void Event::setEnd( const QDateTime &d )
{
    endUTC = TimeConversion::toUTC( d );
}

void Event::setEnd( time_t time )
{
    endUTC = time;
}

void Event::setTimeZone( const QString &z )
{
    tz = z;
}

void Event::setAlarm( bool b, int minutes, SoundTypeChoice s )
{
    hAlarm = b;
    aMinutes = minutes;
    aSound = s;
}

void Event::setRepeat( bool b, const RepeatPattern &p )
{
    hRepeat = b;
    pattern = p;
}

void Event::setNotes( const QString &n )
{
    note = n;
}

const QString &Event::description() const
{
    return descript;
}

const QString &Event::location() const
{
    return locat;
}

// QString Event::category() const
// {
//     return categ;
// }

Event::Type Event::type() const
{
    return typ;
}
/*
QDateTime Event::start() const {
    return start( TRUE );
}
*/
QDateTime Event::start( bool actual ) const
{
    QDateTime dt = TimeConversion::fromUTC( startUTC );

    if ( actual && typ == AllDay ) {
    QTime t = dt.time();
    t.setHMS( 0, 0, 0 );
    dt.setTime( t );
    }
    return dt;
}
/*
QDateTime Event::end() const {
    return end( TRUE );
}
*/
QDateTime Event::end( bool actual ) const
{
    QDateTime dt = TimeConversion::fromUTC( endUTC );
    if ( actual && typ == AllDay ) {
    dt.setTime( QTime(23,59,59) );
    }
    return dt;
}

const QString &Event::timeZone() const
{
    return tz;
}

bool Event::hasAlarm() const
{
    return hAlarm;
}

int Event::alarmTime() const
{
    return aMinutes;
}

Event::SoundTypeChoice Event::alarmSound() const
{
    return aSound;
}

bool Event::hasRepeat() const
{
    return doRepeat();
}

const Event::RepeatPattern &Event::repeatPattern() const
{
    return pattern;
}

Event::RepeatPattern &Event::repeatPattern()
{
    return pattern;
}

const QString &Event::notes() const
{
    return note;
}

bool Event::operator==( const Event &e ) const
{
    if ( uid() && e.uid() == uid() )
    return TRUE;
    return ( e.descript == descript &&
         e.locat == locat &&
         e.categ == categ &&
         e.typ == typ &&
         e.startUTC == startUTC &&
         e.endUTC == endUTC &&
         e.tz == tz &&
         e.hAlarm == hAlarm &&
         e.aMinutes == aMinutes &&
         e.aSound == aSound &&
         e.hRepeat == hRepeat &&
         e.pattern == pattern &&
         e.note == note );
}

void Event::save( QString& buf )
{
    buf += " description=\"" + Qtopia::escapeString(descript) + "\"";
    if ( !locat.isEmpty() )
    buf += " location=\"" + Qtopia::escapeString(locat) + "\"";
    // save the categoies differently....
    QString strCats = idsToString( categories() );
    buf += " categories=\"" + Qtopia::escapeString(strCats) + "\"";
    buf += " uid=\"" + QString::number( uid() ) + "\"";
    if ( (Type)typ != Normal )
    buf += " type=\"AllDay\"";
    if ( hAlarm ) {
    buf += " alarm=\"" + QString::number( aMinutes ) + "\" sound=\"";
    if ( aSound == Event::Loud )
        buf += "loud";
    else
        buf += "silent";
    buf += "\"";
    }
    if ( hRepeat )
    write( buf, pattern );

    buf += " start=\""
       + QString::number( startUTC )
       + "\"";

    buf += " end=\""
       + QString::number( endUTC )
       + "\"";

    if ( !note.isEmpty() )
    buf += " note=\"" + Qtopia::escapeString( note ) + "\"";
    buf += customToXml();
}

bool Event::RepeatPattern::operator==( const Event::RepeatPattern &right ) const
{
    // *sigh*
    return ( type == right.type
         && frequency == right.frequency
         && position == right.position
         && days == right.days
         && hasEndDate == right.hasEndDate
         && endDateUTC == right.endDateUTC
         && createTime == right.createTime );
}

class EffectiveEventPrivate
{
public:
    //currently the existence of the d pointer means multi-day repeating,
    //msut be changed if we use the d pointer for anything else.
    QDate startDate;
    QDate endDate;
};

EffectiveEvent::EffectiveEvent()
{
    mDate = QDate::currentDate();
    mStart = mEnd = QTime::currentTime();
    d = 0;
}

EffectiveEvent::EffectiveEvent( const Event &e, const QDate &date, Position pos )
{
    mEvent = e;
    mDate = date;
    if ( pos & Start )
    mStart = e.start( TRUE ).time();
    else
    mStart = QTime( 0, 0, 0 );

    if ( pos & End )
    mEnd = e.end( TRUE ).time();
    else
    mEnd = QTime( 23, 59, 59 );
    d = 0;
}

EffectiveEvent::~EffectiveEvent()
{
    delete d;
}

EffectiveEvent::EffectiveEvent( const EffectiveEvent &e )
{
    d = 0;
    *this = e;
}

EffectiveEvent& EffectiveEvent::operator=( const EffectiveEvent & e )
{
    if ( &e == this )
    return *this;
    delete d;
    if ( e.d ) {
    d = new EffectiveEventPrivate;
    d->startDate = e.d->startDate;
    d->endDate = e.d->endDate;
    } else {
    d = 0;
    }
    mEvent = e.mEvent;
    mDate = e.mDate;
    mStart = e.mStart;
    mEnd = e.mEnd;

    return *this;

}

// QString EffectiveEvent::category() const
// {
//     return mEvent.category();
// }

const QString &EffectiveEvent::description( ) const
{
    return mEvent.description();
}

const QString &EffectiveEvent::location( ) const
{
    return mEvent.location();
}

const QString &EffectiveEvent::notes() const
{
    return mEvent.notes();
}

const Event &EffectiveEvent::event() const
{
    return mEvent;
}

const QTime &EffectiveEvent::end() const
{
    return mEnd;
}

const QTime &EffectiveEvent::start() const
{
    return mStart;
}

const QDate &EffectiveEvent::date() const
{
    return mDate;
}

int EffectiveEvent::length() const
{
    return (mEnd.hour() * 60 - mStart.hour() * 60)
       + QABS(mStart.minute() - mEnd.minute() );
}

void EffectiveEvent::setDate( const QDate &dt )
{
    mDate = dt;
}

void EffectiveEvent::setStart( const QTime &start )
{
    mStart = start;
}

void EffectiveEvent::setEnd( const QTime &end )
{
    mEnd = end;
}

void EffectiveEvent::setEvent( Event e )
{
    mEvent = e;
}

bool EffectiveEvent::operator<( const EffectiveEvent &e ) const
{
    if ( mDate < e.date() )
    return TRUE;
    if ( mDate == e.date() )
    return ( mStart < e.start() );
    else
    return FALSE;
}

bool EffectiveEvent::operator<=( const EffectiveEvent &e ) const
{
    return (mDate <= e.date() );
}

bool EffectiveEvent::operator==( const EffectiveEvent &e ) const
{
    return ( mDate == e.date()
         && mStart == e.start()
         && mEnd == e.end()
         && mEvent == e.event() );
}

bool EffectiveEvent::operator!=( const EffectiveEvent &e ) const
{
    return !(*this == e);
}

bool EffectiveEvent::operator>( const EffectiveEvent &e ) const
{
    return !(*this <= e );
}

bool EffectiveEvent::operator>=(const EffectiveEvent &e) const
{
    return !(*this < e);
}

void EffectiveEvent::setEffectiveDates( const QDate &from, const QDate &to )
{
    if ( !from.isValid() ) {
    delete d;
    d = 0;
    return;
    }
    if ( !d )
    d = new EffectiveEventPrivate;
    d->startDate = from;
    d->endDate = to;
}

QDate EffectiveEvent::startDate() const
{
    if ( d )
    return d->startDate;
    else if ( mEvent.hasRepeat() )
    return mDate; // single day, since multi-day should have a d pointer
    else
    return mEvent.start().date();
}

QDate EffectiveEvent::endDate() const
{
    if ( d )
    return d->endDate;
    else if ( mEvent.hasRepeat() )
    return mDate; // single day, since multi-day should have a d pointer
    else
    return mEvent.end().date();
}

int EffectiveEvent::size() const
{
    return ( mEnd.hour() - mStart.hour() ) * 3600
         + (mEnd.minute() - mStart.minute() * 60
         + mEnd.second() - mStart.second() );
}


// vcal conversion code
static inline VObject *safeAddPropValue( VObject *o, const char *prop, const QString &value )
{
    VObject *ret = 0;
    if ( o && !value.isEmpty() )
    ret = addPropValue( o, prop, value.latin1() );
    return ret;
}

static inline VObject *safeAddProp( VObject *o, const char *prop)
{
    VObject *ret = 0;
    if ( o )
    ret = addProp( o, prop );
    return ret;
}

/*
 * Until we support vCal/iCal right
 * we will make DTSTART and other things
 * be floating in the sense of
 * RFC 2445
 */
namespace {
/*
 * Convert QDateTime to iso8601 but take
 * local time and do not use the Z at the end
 *
 */
    QCString toISOLocal( const QDateTime& dt ) {
        QCString str;
        /*
         * year month day T Hour Minute Second
         *  4    2     2     2    2       2    digits
         */
        str.sprintf("%04d%02d%02dT%02d%02d%02d",
                    dt.date().year(),
                    dt.date().month(),
                    dt.date().day(),
                    dt.time().hour(),
                    dt.time().minute(),
                    dt.time().second() );

        qWarning("Str ist %s", str.data() );

        return str;
    }


};

static VObject *createVObject( const Event &e )
{
    VObject *vcal = newVObject( VCCalProp );
    safeAddPropValue( vcal, VCVersionProp, "1.0" );
    VObject *event = safeAddProp( vcal, VCEventProp );

    safeAddPropValue( event, VCDTstartProp, toISOLocal( e.start() ) );
    safeAddPropValue( event, VCDTendProp, toISOLocal( e.end() ) );
    safeAddPropValue( event, "X-Qtopia-NOTES", e.description() );
    safeAddPropValue( event, VCDescriptionProp, e.description() );
    safeAddPropValue( event, VCLocationProp, e.location() );

    if ( e.hasAlarm() ) {
    VObject *alarm = safeAddProp( event, VCAAlarmProp );
    QDateTime dt = e.start();
    dt = dt.addSecs( -e.alarmTime()*60 );
    safeAddPropValue( alarm, VCRunTimeProp, toISOLocal( dt ) );
    safeAddPropValue( alarm, VCAudioContentProp,
              (e.alarmSound() == Event::Silent ? "silent" : "alarm" ) );
    }

    safeAddPropValue( event, "X-Qtopia-TIMEZONE", e.timeZone() );

    if ( e.type() == Event::AllDay )
    safeAddPropValue( event, "X-Qtopia-AllDay", e.timeZone() );

    // ### repeat missing

    // ### categories missing

    return vcal;
}


static Event parseVObject( VObject *obj )
{
    Event e;

    bool haveAlarm = FALSE;
    bool haveStart = FALSE;
    bool haveEnd = FALSE;
    QDateTime alarmTime;
    Event::SoundTypeChoice soundType = Event::Silent;

    VObjectIterator it;
    initPropIterator( &it, obj );
    while( moreIteration( &it ) ) {
    VObject *o = nextVObject( &it );
    QCString name = vObjectName( o );
    QCString value = vObjectStringZValue( o );
    if ( name == VCDTstartProp ) {
        e.setStart( TimeConversion::fromISO8601( value ) );
        haveStart = TRUE;
    }
    else if ( name == VCDTendProp ) {
        e.setEnd( TimeConversion::fromISO8601( value ) );
        haveEnd = TRUE;
    }
    else if ( name == "X-Qtopia-NOTES" ) {
        e.setNotes( value );
    }
    else if ( name == VCDescriptionProp ) {
        e.setDescription( value );
    }
    else if ( name == VCLocationProp ) {
        e.setLocation( value );
    }
    else if ( name == VCAudioContentProp ) {
        haveAlarm = TRUE;
        VObjectIterator nit;
        initPropIterator( &nit, o );
        while( moreIteration( &nit ) ) {
        VObject *o = nextVObject( &nit );
        QCString name = vObjectName( o );
        QCString value = vObjectStringZValue( o );
        if ( name == VCRunTimeProp )
            alarmTime = TimeConversion::fromISO8601( value );
        else if ( name == VCAudioContentProp ) {
            if ( value == "silent" )
            soundType = Event::Silent;
            else
            soundType = Event::Loud;
        }
        }
    }
    else if ( name == "X-Qtopia-TIMEZONE") {
        e.setTimeZone( value );
    }
    else if ( name == "X-Qtopia-AllDay" ) {
        e.setType( Event::AllDay );
    }
#if 0
    else {
        printf("Name: %s, value=%s\n", name.data(), vObjectStringZValue( o ) );
        VObjectIterator nit;
        initPropIterator( &nit, o );
        while( moreIteration( &nit ) ) {
        VObject *o = nextVObject( &nit );
        QCString name = vObjectName( o );
        QString value = vObjectStringZValue( o );
        printf(" subprop: %s = %s\n", name.data(), value.latin1() );
        }
    }
#endif
    }

    if ( !haveStart && !haveEnd )
    e.setStart( QDateTime::currentDateTime() );

    if ( !haveEnd ) {
    e.setType( Event::AllDay );
    e.setEnd( e.start() );
    }

    if ( haveAlarm ) {
    int minutes = alarmTime.secsTo( e.start() ) / 60;
    e.setAlarm( TRUE, minutes, soundType );
    }
    return e;
}


void Event::writeVCalendar( const QString &filename, const QValueList<Event> &events)
{

    QFileDirect f( filename.utf8().data() );

    if ( !f.open( IO_WriteOnly ) ) {

        qWarning("Unable to open vcard write");

        return;

    }


    QValueList<Event>::ConstIterator it;
    for( it = events.begin(); it != events.end(); ++it ) {
    VObject *obj = createVObject( *it );
    writeVObject( f.directHandle() , obj );
    cleanVObject( obj );
    }


    cleanStrTbl();
}

void Event::writeVCalendar( const QString &filename, const Event &event)
{

    QFileDirect f( filename.utf8().data() );

    if ( !f.open( IO_WriteOnly ) ) {

        qWarning("Unable to open vcard write");

        return;

    }


    VObject *obj = createVObject( event );
    writeVObject( f.directHandle() , obj );
    cleanVObject( obj );

    cleanStrTbl();
}

QValueList<Event> Event::readVCalendar( const QString &filename )
{
    VObject *obj = Parse_MIME_FromFileName( (char *)filename.utf8().data() );

    QValueList<Event> events;

    while ( obj ) {
    QCString name = vObjectName( obj );
    if ( name == VCCalProp ) {
        VObjectIterator nit;
        initPropIterator( &nit, obj );
        while( moreIteration( &nit ) ) {
        VObject *o = nextVObject( &nit );
        QCString name = vObjectName( o );
        if ( name == VCEventProp )
            events.append( parseVObject( o ) );
        }
    } else if ( name == VCEventProp ) {
        // shouldn't happen, but just to be sure
        events.append( parseVObject( obj ) );
    }
    VObject *t = obj;
    obj = nextVObjectInList(obj);
    cleanVObject( t );
    }

    return events;
}

bool Event::match( const QRegExp &r ) const
{
    bool returnMe;
    returnMe = false;

    if ( descript.find( r ) > -1 )
    returnMe = true;
    else if ( locat.find( r ) > -1 )
    returnMe = true;
    else if ( TimeConversion::fromUTC( startUTC ).toString().find( r ) > -1 )
    returnMe = true;
    else if ( TimeConversion::fromUTC( endUTC ).toString().find( r )  > -1 )
    returnMe = true;
    else if ( tz.find( r ) > -1 )
    returnMe = true;
    else if ( note.find( r ) > -1 )
    returnMe = true;
    else if ( doRepeat() ) {
    if ( pattern.hasEndDate )
        if ( TimeConversion::fromUTC( pattern.endDateUTC ).toString().find(r) > -1 )
        returnMe = true;
    }
    return returnMe;
}

This file is part of the documentation for OPIE Version 1.5.5.

Documentation copyright © 1997-2003 the KDE developers. 2003 OPIE developers
Generated on Tue Feb 10 20:24:04 2004 by doxygen 1.3.5 written by Dimitri van Heesch, © 1997-2001