예제 #1
0
/******************************************************************************
*  Add all the current alarms to the list.
*/
void AlarmListView::populate()
{
    KAEvent event;
    KCal::Event::List events;
    KCal::Event::List::ConstIterator it;
    QDateTime now = QDateTime::currentDateTime();
    if(mShowExpired)
    {
        AlarmCalendar *cal = AlarmCalendar::expiredCalendarOpen();
        if(cal)
        {
            events = cal->events();
            for(it = events.begin();  it != events.end();  ++it)
            {
                KCal::Event *kcalEvent = *it;
                if(kcalEvent->alarms().count() > 0)
                {
                    event.set(*kcalEvent);
                    addEntry(event, now);
                }
            }
        }
    }
    events = AlarmCalendar::activeCalendar()->events();
    for(it = events.begin();  it != events.end();  ++it)
    {
        KCal::Event *kcalEvent = *it;
        event.set(*kcalEvent);
        if(mShowExpired  ||  !event.expired())
            addEntry(event, now);
    }
}
예제 #2
0
UndoAdd::UndoAdd(Undo::Type type, const KAEvent &event, KAEvent::Status cal)
    : UndoItem(type),
      mEventID(KAEvent::uid(event.id(), cal))
{
    setCalendar(cal);
    mDescription = UndoItem::description(event);    // calendar must be set before calling this
}
예제 #3
0
TemplateListViewItem::TemplateListViewItem(TemplateListView* parent, const KAEvent& event)
	: EventListViewItemBase(parent, event)
{
	setLastColumnText();     // set the template name column text

	int index;
	switch (event.action())
	{
		case KAAlarm::FILE:     index = 2;  break;
		case KAAlarm::COMMAND:  index = 3;  break;
		case KAAlarm::EMAIL:    index = 4;  break;
		case KAAlarm::MESSAGE:
		default:                index = 1;  break;
	}
	mIconOrder.sprintf("%01u", index);
	setPixmap(templateListView()->iconColumn(), *eventIcon());
}
예제 #4
0
/******************************************************************************
*  Undo the item, i.e. undo an edit to a previously existing alarm.
*  Create a redo item to reapply the edit.
*  Reply = redo item.
*/
UndoItem *UndoEdit::restore()
{
    kdDebug(5950) << "UndoEdit::restore(" << mNewEventID << ")\n";
    // Retrieve the current state of the alarm
    const KCal::Event *kcalEvent = AlarmCalendar::getEvent(mNewEventID);
    if(!kcalEvent)
    {
        mRestoreError = ERR_NOT_FOUND;    // alarm is no longer in calendar
        return 0;
    }
    KAEvent newEvent(*kcalEvent);

    // Create a redo item to restore the edit
    Undo::Type t = (type() == Undo::UNDO) ? Undo::REDO : (type() == Undo::REDO) ? Undo::UNDO : Undo::NONE;
    UndoItem *undo = new UndoEdit(t, newEvent, mOldEvent->id(), mDescription);

    switch(calendar())
    {
        case KAEvent::ACTIVE:
            switch(KAlarm::modifyEvent(newEvent, *mOldEvent, 0))
            {
                case KAlarm::UPDATE_ERROR:
                case KAlarm::UPDATE_FAILED:
                case KAlarm::SAVE_FAILED:
                    mRestoreError = ERR_CREATE;
                    break;
                case KAlarm::UPDATE_KORG_ERR:
                    mRestoreWarning = WARN_KORG_MODIFY;
                    ++mRestoreWarningCount;
                    break;
                default:
                    break;
            }
            break;
        case KAEvent::TEMPLATE:
            if(KAlarm::updateTemplate(*mOldEvent, 0) != KAlarm::UPDATE_OK)
                mRestoreError = ERR_TEMPLATE;
            break;
        case KAEvent::EXPIRED:    // editing of expired events is not allowed
        default:
            delete undo;
            mRestoreError = ERR_PROG;
            return 0;
    }
    return undo;
}
예제 #5
0
AlarmListViewItem::AlarmListViewItem(AlarmListView *parent, const KAEvent &event, const QDateTime &now)
    : EventListViewItemBase(parent, event),
      mMessageTruncated(false),
      mTimeToAlarmShown(false)
{
    setLastColumnText();     // set the message column text

    DateTime dateTime = event.expired() ? event.startDateTime() : event.displayDateTime();
    if(parent->column(AlarmListView::TIME_COLUMN) >= 0)
        setText(parent->column(AlarmListView::TIME_COLUMN), alarmTimeText(dateTime));
    if(parent->column(AlarmListView::TIME_TO_COLUMN) >= 0)
    {
        QString tta = timeToAlarmText(now);
        setText(parent->column(AlarmListView::TIME_TO_COLUMN), tta);
        mTimeToAlarmShown = !tta.isNull();
    }
    QTime t = dateTime.time();
    mDateTimeOrder.sprintf("%04d%03d%02d%02d", dateTime.date().year(), dateTime.date().dayOfYear(),
                           t.hour(), t.minute());

    int repeatOrder = 0;
    int repeatInterval = 0;
    QString repeatText = event.recurrenceText(true);     // text displayed in Repeat column
    if(repeatText.isEmpty())
        repeatText = event.repetitionText(true);
    if(event.repeatAtLogin())
        repeatOrder = 1;
    else
    {
        repeatInterval = event.recurInterval();
        switch(event.recurType())
        {
            case KARecurrence::MINUTELY:
                repeatOrder = 2;
                break;
            case KARecurrence::DAILY:
                repeatOrder = 3;
                break;
            case KARecurrence::WEEKLY:
                repeatOrder = 4;
                break;
            case KARecurrence::MONTHLY_DAY:
            case KARecurrence::MONTHLY_POS:
                repeatOrder = 5;
                break;
            case KARecurrence::ANNUAL_DATE:
            case KARecurrence::ANNUAL_POS:
                repeatOrder = 6;
                break;
            case KARecurrence::NO_RECUR:
            default:
                break;
        }
    }
    setText(parent->column(AlarmListView::REPEAT_COLUMN), repeatText);
    mRepeatOrder.sprintf("%c%08d", '0' + repeatOrder, repeatInterval);

    bool showColour = (event.action() == KAEvent::MESSAGE || event.action() == KAEvent::FILE);
    mColourOrder.sprintf("%06u", (showColour ? event.bgColour().rgb() : 0));

    mTypeOrder.sprintf("%02d", event.action());
}
예제 #6
0
/******************************************************************************
* Initialise or update the birthday selection list by fetching all birthdays
* from the address book and displaying those which do not already have alarms.
*/
void BirthdayDlg::updateSelectionList()
{
	// Compile a list of all pending alarm messages which look like birthdays
	QStringList messageList;
	KAEvent event;
	Event::List events = AlarmCalendar::activeCalendar()->events();
	for (Event::List::ConstIterator it = events.begin();  it != events.end();  ++it)
	{
		Event* kcalEvent = *it;
		event.set(*kcalEvent);
		if (event.action() == KAEvent::MESSAGE
		&&  event.recurType() == KARecurrence::ANNUAL_DATE
		&&  (mPrefixText.isEmpty()  ||  event.message().startsWith(mPrefixText)))
			messageList.append(event.message());
	}

	// Fetch all birthdays from the address book
	for (KABC::AddressBook::ConstIterator abit = mAddressBook->begin();  abit != mAddressBook->end();  ++abit)
	{
		const KABC::Addressee& addressee = *abit;
		if (addressee.birthday().isValid())
		{
			// Create a list entry for this birthday
			QDate birthday = addressee.birthday().date();
			QString name = addressee.nickName();
			if (name.isEmpty())
				name = addressee.realName();
			// Check if the birthday already has an alarm
			QString text = mPrefixText + name + mSuffixText;
			bool alarmExists = (messageList.find(text) != messageList.end());
			// Check if the birthday is already in the selection list
			bool inSelectionList = false;
			AddresseeItem* item = 0;
			for (QListViewItem* qitem = mAddresseeList->firstChild();  qitem;  qitem = qitem->nextSibling())
			{
				item = dynamic_cast<AddresseeItem*>(qitem);
				if (item  &&  item->text(AddresseeItem::NAME) == name  &&  item->birthday() == birthday)
				{
					inSelectionList = true;
					break;
				}
			}

			if (alarmExists  &&  inSelectionList)
				delete item;     // alarm exists, so remove from selection list
			else if (!alarmExists  &&  !inSelectionList)
				new AddresseeItem(mAddresseeList, name, birthday);   // add to list
		}
	}
//	mAddresseeList->setUpdatesEnabled(true);

	// Enable/disable OK button according to whether anything is currently selected
	bool selection = false;
	for (QListViewItem* item = mAddresseeList->firstChild();  item;  item = item->nextSibling())
		if (mAddresseeList->isSelected(item))
		{
			selection = true;
			break;
		}
	enableButtonOK(selection);
}
예제 #7
0
/******************************************************************************
*  Undo the item, i.e. restore an alarm which was deleted.
*  Create a redo item to delete the alarm again.
*  Reply = redo item.
*/
UndoItem *UndoDelete::restore()
{
    kdDebug(5950) << "UndoDelete::restore(" << mEvent->id() << ")\n";
    // Restore the original event
    switch(calendar())
    {
        case KAEvent::ACTIVE:
            if(mEvent->toBeArchived())
            {
                // It was archived when it was deleted
                mEvent->setUid(KAEvent::EXPIRED);
                switch(KAlarm::reactivateEvent(*mEvent, 0, true))
                {
                    case KAlarm::UPDATE_KORG_ERR:
                        mRestoreWarning = WARN_KORG_ADD;
                        ++mRestoreWarningCount;
                        break;
                    case KAlarm::UPDATE_ERROR:
                    case KAlarm::UPDATE_FAILED:
                    case KAlarm::SAVE_FAILED:
                        mRestoreError = ERR_EXPIRED;
                        return 0;
                    case KAlarm::UPDATE_OK:
                        break;
                }
            }
            else
            {
                switch(KAlarm::addEvent(*mEvent, 0, 0, true))
                {
                    case KAlarm::UPDATE_KORG_ERR:
                        mRestoreWarning = WARN_KORG_ADD;
                        ++mRestoreWarningCount;
                        break;
                    case KAlarm::UPDATE_ERROR:
                    case KAlarm::UPDATE_FAILED:
                    case KAlarm::SAVE_FAILED:
                        mRestoreError = ERR_CREATE;
                        return 0;
                    case KAlarm::UPDATE_OK:
                        break;
                }
            }
            break;
        case KAEvent::TEMPLATE:
            if(KAlarm::addTemplate(*mEvent, 0) != KAlarm::UPDATE_OK)
            {
                mRestoreError = ERR_CREATE;
                return 0;
            }
            break;
        case KAEvent::EXPIRED:
            if(!KAlarm::addExpiredEvent(*mEvent))
            {
                mRestoreError = ERR_CREATE;
                return 0;
            }
            break;
        default:
            mRestoreError = ERR_PROG;
            return 0;
    }

    // Create a redo item to delete the alarm again
    return createRedo(*mEvent);
}
예제 #8
0
/******************************************************************************
*  Return the description of an event.
*/
QString UndoItem::description(const KAEvent &event) const
{
    return (mCalendar == KAEvent::TEMPLATE) ? event.templateName() : AlarmText::summary(event);
}
예제 #9
0
void Undo::saveDelete(const KAEvent &event)
{
    new UndoDelete(UNDO, event);
    removeRedos(event.id());    // remove any redos which are made invalid by this deletion
    emitChanged();
}
예제 #10
0
void Undo::saveEdit(const KAEvent &oldEvent, const KAEvent &newEvent)
{
    new UndoEdit(UNDO, oldEvent, newEvent.id(), AlarmText::summary(newEvent));
    removeRedos(oldEvent.id());    // remove any redos which are made invalid by this edit
    emitChanged();
}