diff --git a/src/functions.cpp b/src/functions.cpp index a8dcca87..4cf5000b 100644 --- a/src/functions.cpp +++ b/src/functions.cpp @@ -1,1985 +1,1985 @@ /* * functions.cpp - miscellaneous functions * Program: kalarm * Copyright © 2001-2020 David Jarvie * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "functions.h" #include "functions_p.h" #include "akonadicollectionsearch.h" #include "alarmcalendar.h" #include "editdlg.h" #include "kalarmapp.h" #include "kamail.h" #include "mainwindow.h" #include "messagewin.h" #include "preferences.h" #include "templatelistview.h" #include "templatemenuaction.h" #include "resources/calendarfunctions.h" #include "resources/datamodel.h" #include "resources/resources.h" #include "resources/eventmodel.h" #include "lib/autoqpointer.h" #include "lib/filedialog.h" #include "lib/messagebox.h" #include "lib/shellprocess.h" #include "config-kalarm.h" #include "kalarm_debug.h" #include #include #include #include #include #include #include #include using namespace KCalendarCore; #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace { bool refreshAlarmsQueued = false; QUrl lastImportUrl; // last URL for Import Alarms file dialogue QUrl lastExportUrl; // last URL for Export Alarms file dialogue struct UpdateStatusData { KAlarm::UpdateResult status; // status code and KOrganizer error message if any int warnErr; int warnKOrg; explicit UpdateStatusData(KAlarm::UpdateStatus s = KAlarm::UPDATE_OK) : status(s), warnErr(0), warnKOrg(0) {} // Set an error status and increment to number of errors to warn about void setError(KAlarm::UpdateStatus st, int errorCount = -1) { status.set(st); if (errorCount < 0) ++warnErr; else warnErr = errorCount; } // Update the error status with a KOrganizer related status void korgUpdate(const KAlarm::UpdateResult& result) { if (result.status != KAlarm::UPDATE_OK) { ++warnKOrg; if (result.status > status.status) status = result; } } }; const QLatin1String KMAIL_DBUS_SERVICE("org.kde.kmail"); //const QLatin1String KMAIL_DBUS_IFACE("org.kde.kmail.kmail"); //const QLatin1String KMAIL_DBUS_WINDOW_PATH("/kmail/kmail_mainwindow_1"); const QLatin1String KORG_DBUS_SERVICE("org.kde.korganizer"); const QLatin1String KORG_DBUS_IFACE("org.kde.korganizer.Korganizer"); // D-Bus object path of KOrganizer's notification interface #define KORG_DBUS_PATH "/Korganizer" #define KORG_DBUS_LOAD_PATH "/korganizer_PimApplication" //const QLatin1String KORG_DBUS_WINDOW_PATH("/korganizer/MainWindow_1"); const QLatin1String KORG_MIME_TYPE("application/x-vnd.akonadi.calendar.event"); const QLatin1String KORGANIZER_UID("korg-"); const QLatin1String ALARM_OPTS_FILE("alarmopts"); const char* DONT_SHOW_ERRORS_GROUP = "DontShowErrors"; void editNewTemplate(EditAlarmDlg::Type, const KAEvent* preset, QWidget* parent); void displayUpdateError(QWidget* parent, KAlarm::UpdateError, const UpdateStatusData&, bool showKOrgError = true); KAlarm::UpdateResult sendToKOrganizer(const KAEvent&); KAlarm::UpdateResult deleteFromKOrganizer(const QString& eventID); KAlarm::UpdateResult runKOrganizer(); QString uidKOrganizer(const QString& eventID); } namespace KAlarm { Private* Private::mInstance = nullptr; /****************************************************************************** * Display a main window with the specified event selected. */ MainWindow* displayMainWindowSelected(const QString& eventId) { MainWindow* win = MainWindow::firstWindow(); if (!win) { if (theApp()->checkCalendar()) // ensure calendar is open { win = MainWindow::create(); win->show(); } } else { // There is already a main window, so make it the active window #pragma message("Don't hide unless necessary, since it moves the window") win->hide(); // in case it's on a different desktop win->setWindowState(win->windowState() & ~Qt::WindowMinimized); win->show(); win->raise(); win->activateWindow(); } if (win) win->selectEvent(eventId); return win; } /****************************************************************************** * Create an "Alarms Enabled/Enable Alarms" action. */ KToggleAction* createAlarmEnableAction(QObject* parent) { KToggleAction* action = new KToggleAction(i18nc("@action", "Enable &Alarms"), parent); action->setChecked(theApp()->alarmsEnabled()); QObject::connect(action, &QAction::toggled, theApp(), &KAlarmApp::setAlarmsEnabled); // The following line ensures that all instances are kept in the same state QObject::connect(theApp(), &KAlarmApp::alarmEnabledToggled, action, &QAction::setChecked); return action; } /****************************************************************************** * Create a "Stop Play" action. */ QAction* createStopPlayAction(QObject* parent) { QAction* action = new QAction(QIcon::fromTheme(QStringLiteral("media-playback-stop")), i18nc("@action", "Stop Play"), parent); action->setEnabled(MessageWin::isAudioPlaying()); QObject::connect(action, &QAction::triggered, theApp(), &KAlarmApp::stopAudio); // The following line ensures that all instances are kept in the same state QObject::connect(theApp(), &KAlarmApp::audioPlaying, action, &QAction::setEnabled); return action; } /****************************************************************************** * Create a "Spread Windows" action. */ KToggleAction* createSpreadWindowsAction(QObject* parent) { KToggleAction* action = new KToggleAction(i18nc("@action", "Spread Windows"), parent); QObject::connect(action, &QAction::triggered, theApp(), &KAlarmApp::spreadWindows); // The following line ensures that all instances are kept in the same state QObject::connect(theApp(), &KAlarmApp::spreadWindowsToggled, action, &QAction::setChecked); return action; } /****************************************************************************** * Add a new active (non-archived) alarm. * Save it in the calendar file and add it to every main window instance. * Parameters: msgParent = parent widget for any calendar selection prompt or * error message. * event - is updated with the actual event ID. */ UpdateResult addEvent(KAEvent& event, Resource* resource, QWidget* msgParent, int options, bool showKOrgErr) { qCDebug(KALARM_LOG) << "KAlarm::addEvent:" << event.id(); bool cancelled = false; UpdateStatusData status; if (!theApp()->checkCalendar()) // ensure calendar is open status.status = UPDATE_FAILED; else { // Save the event details in the calendar file, and get the new event ID ResourcesCalendar* cal = ResourcesCalendar::instance(); // Note that AlarmCalendar::addEvent() updates 'event'. if (!cal->addEvent(event, msgParent, (options & USE_EVENT_ID), resource, (options & NO_RESOURCE_PROMPT), &cancelled)) { status.status = UPDATE_FAILED; } else { if (!cal->save()) status.status = SAVE_FAILED; } if (status.status == UPDATE_OK) { if ((options & ALLOW_KORG_UPDATE) && event.copyToKOrganizer()) { UpdateResult st = sendToKOrganizer(event); // tell KOrganizer to show the event status.korgUpdate(st); } } } if (status.status != UPDATE_OK && !cancelled && msgParent) displayUpdateError(msgParent, ERR_ADD, status, showKOrgErr); return status.status; } /****************************************************************************** * Add a list of new active (non-archived) alarms. * Save them in the calendar file and add them to every main window instance. * The events are updated with their actual event IDs. */ UpdateResult addEvents(QVector& events, QWidget* msgParent, bool allowKOrgUpdate, bool showKOrgErr) { qCDebug(KALARM_LOG) << "KAlarm::addEvents:" << events.count(); if (events.isEmpty()) return UpdateResult(UPDATE_OK); UpdateStatusData status; if (!theApp()->checkCalendar()) // ensure calendar is open status.status = UPDATE_FAILED; else { Resource resource = Resources::destination(CalEvent::ACTIVE, msgParent); if (!resource.isValid()) { qCDebug(KALARM_LOG) << "KAlarm::addEvents: No calendar"; status.status = UPDATE_FAILED; } else { ResourcesCalendar* cal = ResourcesCalendar::instance(); for (int i = 0, end = events.count(); i < end; ++i) { // Save the event details in the calendar file, and get the new event ID KAEvent& event = events[i]; if (!cal->addEvent(event, msgParent, false, &resource)) { status.setError(UPDATE_ERROR); continue; } if (allowKOrgUpdate && event.copyToKOrganizer()) { UpdateResult st = sendToKOrganizer(event); // tell KOrganizer to show the event status.korgUpdate(st); } } if (status.warnErr == events.count()) status.status = UPDATE_FAILED; else if (!cal->save()) status.setError(SAVE_FAILED, events.count()); // everything failed } } if (status.status != UPDATE_OK && msgParent) displayUpdateError(msgParent, ERR_ADD, status, showKOrgErr); return status.status; } /****************************************************************************** * Save the event in the archived calendar and adjust every main window instance. * The event's ID is changed to an archived ID if necessary. */ bool addArchivedEvent(KAEvent& event, Resource* resourceptr) { qCDebug(KALARM_LOG) << "KAlarm::addArchivedEvent:" << event.id(); bool archiving = (event.category() == CalEvent::ACTIVE); if (archiving && !Preferences::archivedKeepDays()) return false; // expired alarms aren't being kept ResourcesCalendar* cal = ResourcesCalendar::instance(); KAEvent newevent(event); KAEvent* const newev = &newevent; if (archiving) { newev->setCategory(CalEvent::ARCHIVED); // this changes the event ID newev->setCreatedDateTime(KADateTime::currentUtcDateTime()); // time stamp to control purging } // Note that archived resources are automatically saved after changes are made if (!cal->addEvent(newevent, nullptr, false, resourceptr)) return false; event = *newev; // update event ID etc. return true; } /****************************************************************************** * Add a new template. * Save it in the calendar file and add it to every template list view. * 'event' is updated with the actual event ID. * Parameters: promptParent = parent widget for any calendar selection prompt. */ UpdateResult addTemplate(KAEvent& event, Resource* resourceptr, QWidget* msgParent) { qCDebug(KALARM_LOG) << "KAlarm::addTemplate:" << event.id(); UpdateStatusData status; // Add the template to the calendar file ResourcesCalendar* cal = ResourcesCalendar::instance(); KAEvent newev(event); if (!cal->addEvent(newev, msgParent, false, resourceptr)) status.status = UPDATE_FAILED; else { event = newev; // update event ID etc. if (!cal->save()) status.status = SAVE_FAILED; else { return UpdateResult(UPDATE_OK); } } if (msgParent) displayUpdateError(msgParent, ERR_TEMPLATE, status); return status.status; } /****************************************************************************** * Modify an active (non-archived) alarm in the calendar file and in every main * window instance. * The new event must have a different event ID from the old one. */ UpdateResult modifyEvent(KAEvent& oldEvent, KAEvent& newEvent, QWidget* msgParent, bool showKOrgErr) { qCDebug(KALARM_LOG) << "KAlarm::modifyEvent:" << oldEvent.id(); UpdateStatusData status; if (!newEvent.isValid()) { deleteEvent(oldEvent, true); status.status = UPDATE_FAILED; } else { EventId oldId(oldEvent); if (oldEvent.copyToKOrganizer()) { // Tell KOrganizer to delete its old event. // But ignore errors, because the user could have manually // deleted it since KAlarm asked KOrganizer to set it up. deleteFromKOrganizer(oldId.eventId()); } // Update the event in the calendar file, and get the new event ID ResourcesCalendar* cal = ResourcesCalendar::instance(); if (!cal->modifyEvent(oldId, newEvent)) status.status = UPDATE_FAILED; else { if (!cal->save()) status.status = SAVE_FAILED; if (status.status == UPDATE_OK) { if (newEvent.copyToKOrganizer()) { UpdateResult st = sendToKOrganizer(newEvent); // tell KOrganizer to show the new event status.korgUpdate(st); } // Remove "Don't show error messages again" for the old alarm setDontShowErrors(oldId); } } } if (status.status != UPDATE_OK && msgParent) displayUpdateError(msgParent, ERR_MODIFY, status, showKOrgErr); return status.status; } /****************************************************************************** * Update an active (non-archived) alarm from the calendar file and from every * main window instance. * The new event will have the same event ID as the old one. * The event is not updated in KOrganizer, since this function is called when an * existing alarm is rescheduled (due to recurrence or deferral). */ UpdateResult updateEvent(KAEvent& event, QWidget* msgParent, bool archiveOnDelete) { qCDebug(KALARM_LOG) << "KAlarm::updateEvent:" << event.id(); if (!event.isValid()) deleteEvent(event, archiveOnDelete); else { // Update the event in the calendar file. ResourcesCalendar* cal = ResourcesCalendar::instance(); cal->updateEvent(event); if (!cal->save()) { if (msgParent) displayUpdateError(msgParent, ERR_ADD, UpdateStatusData(SAVE_FAILED)); return UpdateResult(SAVE_FAILED); } } return UpdateResult(UPDATE_OK); } /****************************************************************************** * Update a template in the calendar file and in every template list view. * If 'selectionView' is non-null, the selection highlight is moved to the * updated event in that listView instance. */ UpdateResult updateTemplate(KAEvent& event, QWidget* msgParent) { ResourcesCalendar* cal = ResourcesCalendar::instance(); const KAEvent* newEvent = cal->updateEvent(event); UpdateStatus status = UPDATE_OK; if (!newEvent) status = UPDATE_FAILED; else if (!cal->save()) status = SAVE_FAILED; if (status != UPDATE_OK) { if (msgParent) displayUpdateError(msgParent, ERR_TEMPLATE, UpdateStatusData(status)); return UpdateResult(status); } return UpdateResult(UPDATE_OK); } /****************************************************************************** * Delete alarms from the calendar file and from every main window instance. * If the events are archived, the events' IDs are changed to archived IDs if necessary. */ UpdateResult deleteEvent(KAEvent& event, bool archive, QWidget* msgParent, bool showKOrgErr) { QVector events(1, event); return deleteEvents(events, archive, msgParent, showKOrgErr); } UpdateResult deleteEvents(QVector& events, bool archive, QWidget* msgParent, bool showKOrgErr) { qCDebug(KALARM_LOG) << "KAlarm::deleteEvents:" << events.count(); if (events.isEmpty()) return UpdateResult(UPDATE_OK); UpdateStatusData status; ResourcesCalendar* cal = ResourcesCalendar::instance(); bool deleteWakeFromSuspendAlarm = false; const QString wakeFromSuspendId = checkRtcWakeConfig().value(0); for (int i = 0, end = events.count(); i < end; ++i) { // Save the event details in the calendar file, and get the new event ID KAEvent* event = &events[i]; const QString id = event->id(); // Delete the event from the calendar file if (event->category() != CalEvent::ARCHIVED) { if (event->copyToKOrganizer()) { // The event was shown in KOrganizer, so tell KOrganizer to // delete it. But ignore errors, because the user could have // manually deleted it from KOrganizer since it was set up. UpdateResult st = deleteFromKOrganizer(id); status.korgUpdate(st); } if (archive && event->toBeArchived()) { KAEvent ev(*event); addArchivedEvent(ev); // this changes the event ID to an archived ID } } if (!cal->deleteEvent(*event, false)) // don't save calendar after deleting status.setError(UPDATE_ERROR); if (id == wakeFromSuspendId) deleteWakeFromSuspendAlarm = true; // Remove "Don't show error messages again" for this alarm setDontShowErrors(EventId(*event)); } if (status.warnErr == events.count()) status.status = UPDATE_FAILED; else if (!cal->save()) // save the calendars now status.setError(SAVE_FAILED, events.count()); if (status.status != UPDATE_OK && msgParent) displayUpdateError(msgParent, ERR_DELETE, status, showKOrgErr); // Remove any wake-from-suspend scheduled for a deleted alarm if (deleteWakeFromSuspendAlarm && !wakeFromSuspendId.isEmpty()) cancelRtcWake(msgParent, wakeFromSuspendId); return status.status; } /****************************************************************************** * Delete templates from the calendar file and from every template list view. */ UpdateResult deleteTemplates(const KAEvent::List& events, QWidget* msgParent) { int count = events.count(); qCDebug(KALARM_LOG) << "KAlarm::deleteTemplates:" << count; if (!count) return UpdateResult(UPDATE_OK); UpdateStatusData status; ResourcesCalendar* cal = ResourcesCalendar::instance(); for (const KAEvent* event : events) { // Update the window lists // Delete the template from the calendar file if (!cal->deleteEvent(*event, false)) // don't save calendar after deleting status.setError(UPDATE_ERROR); } if (status.warnErr == count) status.status = UPDATE_FAILED; else if (!cal->save()) // save the calendars now status.setError(SAVE_FAILED, count); if (status.status != UPDATE_OK && msgParent) displayUpdateError(msgParent, ERR_TEMPLATE, status); return status.status; } /****************************************************************************** * Delete an alarm from the display calendar. */ void deleteDisplayEvent(const QString& eventID) { qCDebug(KALARM_LOG) << "KAlarm::deleteDisplayEvent:" << eventID; DisplayCalendar* cal = DisplayCalendar::instanceOpen(); if (cal) cal->deleteEvent(eventID, true); // save calendar after deleting } /****************************************************************************** * Undelete archived alarms, and update every main window instance. * The archive bit is set to ensure that they get re-archived if deleted again. * Parameters: * calendar - the active alarms calendar to restore the alarms into, or null * to use the default way of determining the active alarm calendar. * ineligibleIDs - will be filled in with the IDs of any ineligible events. */ UpdateResult reactivateEvent(KAEvent& event, Resource* resourceptr, QWidget* msgParent, bool showKOrgErr) { QVector ids; QVector events(1, event); return reactivateEvents(events, ids, resourceptr, msgParent, showKOrgErr); } UpdateResult reactivateEvents(QVector& events, QVector& ineligibleIDs, Resource* resourceptr, QWidget* msgParent, bool showKOrgErr) { qCDebug(KALARM_LOG) << "KAlarm::reactivateEvents:" << events.count(); ineligibleIDs.clear(); if (events.isEmpty()) return UpdateResult(UPDATE_OK); UpdateStatusData status; Resource resource; if (resourceptr) resource = *resourceptr; if (!resource.isValid()) resource = Resources::destination(CalEvent::ACTIVE, msgParent); if (!resource.isValid()) { qCDebug(KALARM_LOG) << "KAlarm::reactivateEvents: No calendar"; status.setError(UPDATE_FAILED, events.count()); } else { int count = 0; ResourcesCalendar* cal = ResourcesCalendar::instance(); const KADateTime now = KADateTime::currentUtcDateTime(); for (int i = 0, end = events.count(); i < end; ++i) { // Delete the event from the archived resource KAEvent* event = &events[i]; if (event->category() != CalEvent::ARCHIVED || !event->occursAfter(now, true)) { ineligibleIDs += EventId(*event); continue; } ++count; KAEvent newevent(*event); KAEvent* const newev = &newevent; newev->setCategory(CalEvent::ACTIVE); // this changes the event ID if (newev->recurs() || newev->repetition()) newev->setNextOccurrence(now); // skip any recurrences in the past newev->setArchive(); // ensure that it gets re-archived if it is deleted // Save the event details in the calendar file. // This converts the event ID. if (!cal->addEvent(newevent, msgParent, true, &resource)) { status.setError(UPDATE_ERROR); continue; } if (newev->copyToKOrganizer()) { UpdateResult st = sendToKOrganizer(*newev); // tell KOrganizer to show the event status.korgUpdate(st); } if (cal->event(EventId(*event)) // no error if event doesn't exist in archived resource && !cal->deleteEvent(*event, false)) // don't save calendar after deleting status.setError(UPDATE_ERROR); events[i] = newevent; } if (status.warnErr == count) status.status = UPDATE_FAILED; // Save the calendars, even if all events failed, since more than one calendar was updated if (!cal->save() && status.status != UPDATE_FAILED) status.setError(SAVE_FAILED, count); } if (status.status != UPDATE_OK && msgParent) displayUpdateError(msgParent, ERR_REACTIVATE, status, showKOrgErr); return status.status; } /****************************************************************************** * Enable or disable alarms in the calendar file and in every main window instance. * The new events will have the same event IDs as the old ones. */ UpdateResult enableEvents(QVector& events, bool enable, QWidget* msgParent) { qCDebug(KALARM_LOG) << "KAlarm::enableEvents:" << events.count(); if (events.isEmpty()) return UpdateResult(UPDATE_OK); UpdateStatusData status; ResourcesCalendar* cal = ResourcesCalendar::instance(); bool deleteWakeFromSuspendAlarm = false; const QString wakeFromSuspendId = checkRtcWakeConfig().value(0); for (int i = 0, end = events.count(); i < end; ++i) { KAEvent* event = &events[i]; if (event->category() == CalEvent::ACTIVE && enable != event->enabled()) { event->setEnabled(enable); if (!enable && event->id() == wakeFromSuspendId) deleteWakeFromSuspendAlarm = true; // Update the event in the calendar file const KAEvent* newev = cal->updateEvent(*event); if (!newev) qCCritical(KALARM_LOG) << "KAlarm::enableEvents: Error updating event in calendar:" << event->id(); else { cal->disabledChanged(newev); // If we're disabling a display alarm, close any message window if (!enable && (event->actionTypes() & KAEvent::ACT_DISPLAY)) { MessageWin* win = MessageWin::findEvent(EventId(*event)); delete win; } } } } if (!cal->save()) status.setError(SAVE_FAILED, events.count()); if (status.status != UPDATE_OK && msgParent) displayUpdateError(msgParent, ERR_ADD, status); // Remove any wake-from-suspend scheduled for a disabled alarm if (deleteWakeFromSuspendAlarm && !wakeFromSuspendId.isEmpty()) cancelRtcWake(msgParent, wakeFromSuspendId); return status.status; } /****************************************************************************** * This method must only be called from the main KAlarm queue processing loop, * to prevent asynchronous calendar operations interfering with one another. * * Purge all archived events from the default archived alarm resource whose end * time is longer ago than 'purgeDays'. All events are deleted if 'purgeDays' is * zero. */ void purgeArchive(int purgeDays) { if (purgeDays < 0) return; qCDebug(KALARM_LOG) << "KAlarm::purgeArchive:" << purgeDays; const QDate cutoff = KADateTime::currentLocalDate().addDays(-purgeDays); const Resource resource = Resources::getStandard(CalEvent::ARCHIVED); if (!resource.isValid()) return; KAEvent::List events = ResourcesCalendar::instance()->events(resource); for (int i = 0; i < events.count(); ) { if (purgeDays && events.at(i)->createdDateTime().date() >= cutoff) events.remove(i); else ++i; } if (!events.isEmpty()) ResourcesCalendar::instance()->purgeEvents(events); // delete the events and save the calendar } /****************************************************************************** * Display an error message about an error when saving an event. * If 'model' is non-null, the AlarmListModel* which it points to is used; if * that is null, it is created. */ QVector getSortedActiveEvents(QObject* parent, AlarmListModel** model) { AlarmListModel* mdl = nullptr; if (!model) model = &mdl; if (!*model) { *model = DataModel::createAlarmListModel(parent); (*model)->setEventTypeFilter(CalEvent::ACTIVE); (*model)->sort(AlarmListModel::TimeColumn); } QVector result; for (int i = 0, count = (*model)->rowCount(); i < count; ++i) { const KAEvent event = (*model)->event(i); if (event.enabled() && !event.expired()) result += event; } return result; } /****************************************************************************** * Import alarms from an external calendar and merge them into KAlarm's calendar. * The alarms are given new unique event IDs. * Parameters: parent = parent widget for error message boxes * Reply = true if all alarms in the calendar were successfully imported * = false if any alarms failed to be imported. */ bool importAlarms(Resource& resource, QWidget* parent) { qCDebug(KALARM_LOG) << "KAlarm::importAlarms" << resource.displayId(); const QList urls = QFileDialog::getOpenFileUrls( parent, i18nc("@title:window", "Import Calendar Files"), lastImportUrl, - QStringLiteral("%1 (*.ics *.vcs);;%2 (*)").arg(i18nc("@item:inlistbox File type selection filter", "Calendar Files")).arg(i18nc("@item:inlistbox File type selection filter", "All Files"))); + QStringLiteral("%1 (*.ics *.vcs);;%2 (*[^~])").arg(i18nc("@item:inlistbox File type selection filter", "Calendar files")).arg(i18nc("@item:inlistbox File type selection filter", "All files except backup files"))); if (urls.isEmpty()) return false; lastImportUrl = urls[0].adjusted(QUrl::RemoveFilename); const CalEvent::Types alarmTypes = resource.isValid() ? resource.alarmTypes() : CalEvent::ACTIVE | CalEvent::ARCHIVED | CalEvent::TEMPLATE; // Read all the selected calendar files and extract their alarms. QHash> events; for (const QUrl& url : urls) { if (!url.isValid()) { qCDebug(KALARM_LOG) << "KAlarm::importAlarms: Invalid URL"; continue; } qCDebug(KALARM_LOG) << "KAlarm::importAlarms:" << url.toDisplayString(); importCalendarFile(url, alarmTypes, true, parent, events); } if (events.isEmpty()) return false; // Add the alarms to the destination resource. bool success = true; for (auto it = events.constBegin(); it != events.constEnd(); ++it) { Resource res; if (resource.isValid()) res = resource; else res = Resources::destination(it.key()); for (const KAEvent& event : qAsConst(it.value())) { if (!res.addEvent(event)) success = false; } } return success; } /****************************************************************************** * Export all selected alarms to an external calendar. * The alarms are given new unique event IDs. * Parameters: parent = parent widget for error message boxes * Reply = true if all alarms in the calendar were successfully exported * = false if any alarms failed to be exported. */ bool exportAlarms(const KAEvent::List& events, QWidget* parent) { bool append; QString file = FileDialog::getSaveFileName(lastExportUrl, QStringLiteral("*.ics|%1").arg(i18nc("@item:inlistbox File type selection filter", "Calendar Files")), parent, i18nc("@title:window", "Choose Export Calendar"), &append); if (file.isEmpty()) return false; const QUrl url = QUrl::fromLocalFile(file); if (!url.isValid()) { qCDebug(KALARM_LOG) << "KAlarm::exportAlarms: Invalid URL" << url; return false; } lastExportUrl = url.adjusted(QUrl::RemoveFilename); qCDebug(KALARM_LOG) << "KAlarm::exportAlarms:" << url.toDisplayString(); MemoryCalendar::Ptr calendar(new MemoryCalendar(Preferences::timeSpecAsZone())); FileStorage::Ptr calStorage(new FileStorage(calendar, file)); if (append && !calStorage->load()) { auto statJob = KIO::statDetails(url, KIO::StatJob::SourceSide, KIO::StatDetail::StatDefaultDetails); KJobWidgets::setWindow(statJob, parent); statJob->exec(); KFileItem fi(statJob->statResult(), url); if (fi.size()) { qCCritical(KALARM_LOG) << "KAlarm::exportAlarms: Error loading calendar file" << file << "for append"; KAMessageBox::error(MainWindow::mainMainWindow(), xi18nc("@info", "Error loading calendar to append to:%1", url.toDisplayString())); return false; } } KACalendar::setKAlarmVersion(calendar); // Add the alarms to the calendar bool success = true; bool exported = false; for (int i = 0, end = events.count(); i < end; ++i) { const KAEvent* event = events[i]; Event::Ptr kcalEvent(new Event); const CalEvent::Type type = event->category(); const QString id = CalEvent::uid(kcalEvent->uid(), type); kcalEvent->setUid(id); event->updateKCalEvent(kcalEvent, KAEvent::UID_IGNORE); if (calendar->addEvent(kcalEvent)) exported = true; else success = false; } if (exported) { // One or more alarms have been exported to the calendar. // Save the calendar to file. QTemporaryFile* tempFile = nullptr; bool local = url.isLocalFile(); if (!local) { tempFile = new QTemporaryFile; file = tempFile->fileName(); } calStorage->setFileName(file); calStorage->setSaveFormat(new ICalFormat); if (!calStorage->save()) { qCCritical(KALARM_LOG) << "KAlarm::exportAlarms:" << file << ": failed"; KAMessageBox::error(MainWindow::mainMainWindow(), xi18nc("@info", "Failed to save new calendar to:%1", url.toDisplayString())); success = false; } else if (!local) { QFile qFile(file); qFile.open(QIODevice::ReadOnly); auto uploadJob = KIO::storedPut(&qFile, url, -1); KJobWidgets::setWindow(uploadJob, parent); if (!uploadJob->exec()) { qCCritical(KALARM_LOG) << "KAlarm::exportAlarms:" << file << ": upload failed"; KAMessageBox::error(MainWindow::mainMainWindow(), xi18nc("@info", "Cannot upload new calendar to:%1", url.toDisplayString())); success = false; } } delete tempFile; } calendar->close(); return success; } /****************************************************************************** * Display an error message corresponding to a specified alarm update error code. */ void displayKOrgUpdateError(QWidget* parent, UpdateError code, const UpdateResult& korgError, int nAlarms) { QString errmsg; switch (code) { case ERR_ADD: case ERR_REACTIVATE: errmsg = (nAlarms > 1) ? i18nc("@info", "Unable to show alarms in KOrganizer") : i18nc("@info", "Unable to show alarm in KOrganizer"); break; case ERR_MODIFY: errmsg = i18nc("@info", "Unable to update alarm in KOrganizer"); break; case ERR_DELETE: errmsg = (nAlarms > 1) ? i18nc("@info", "Unable to delete alarms from KOrganizer") : i18nc("@info", "Unable to delete alarm from KOrganizer"); break; case ERR_TEMPLATE: return; } bool showDetail = !korgError.message.isEmpty(); QString msg; switch (korgError.status) { case UPDATE_KORG_ERRINIT: msg = xi18nc("@info", "%1(Could not start KOrganizer)", errmsg); break; case UPDATE_KORG_ERRSTART: msg = xi18nc("@info", "%1(KOrganizer not fully started)", errmsg); break; case UPDATE_KORG_ERR: msg = xi18nc("@info", "%1(Error communicating with KOrganizer)", errmsg); break; default: msg = errmsg; showDetail = false; break; } if (showDetail) KAMessageBox::detailedError(parent, msg, korgError.message); else KAMessageBox::error(parent, msg); } /****************************************************************************** * Execute a New Alarm dialog for the specified alarm type. */ void editNewAlarm(EditAlarmDlg::Type type, QWidget* parent) { execNewAlarmDlg(EditAlarmDlg::create(false, type, parent)); } /****************************************************************************** * Execute a New Alarm dialog for the specified alarm type. */ void editNewAlarm(KAEvent::SubAction action, QWidget* parent, const AlarmText* text) { bool setAction = false; EditAlarmDlg::Type type; switch (action) { case KAEvent::MESSAGE: case KAEvent::FILE: type = EditAlarmDlg::DISPLAY; setAction = true; break; case KAEvent::COMMAND: type = EditAlarmDlg::COMMAND; break; case KAEvent::EMAIL: type = EditAlarmDlg::EMAIL; break; case KAEvent::AUDIO: type = EditAlarmDlg::AUDIO; break; default: return; } EditAlarmDlg* editDlg = EditAlarmDlg::create(false, type, parent); if (setAction || text) editDlg->setAction(action, *text); execNewAlarmDlg(editDlg); } /****************************************************************************** * Execute a New Alarm dialog, optionally either presetting it to the supplied * event, or setting the action and text. */ void editNewAlarm(const KAEvent* preset, QWidget* parent) { execNewAlarmDlg(EditAlarmDlg::create(false, preset, true, parent)); } /****************************************************************************** * Common code for editNewAlarm() variants. */ void execNewAlarmDlg(EditAlarmDlg* editDlg) { // Create a PrivateNewAlarmDlg parented by editDlg. // It will be deleted when editDlg is closed. new PrivateNewAlarmDlg(editDlg); editDlg->show(); editDlg->raise(); editDlg->activateWindow(); } PrivateNewAlarmDlg::PrivateNewAlarmDlg(EditAlarmDlg* dlg) : QObject(dlg) { connect(dlg, &QDialog::accepted, this, &PrivateNewAlarmDlg::okClicked); connect(dlg, &QDialog::rejected, this, &PrivateNewAlarmDlg::cancelClicked); } /****************************************************************************** * Called when the dialogue is accepted (e.g. by clicking the OK button). * Creates the event specified in the instance's dialogue. */ void PrivateNewAlarmDlg::okClicked() { accept(static_cast(parent())); } /****************************************************************************** * Creates the event specified in a given dialogue. */ void PrivateNewAlarmDlg::accept(EditAlarmDlg* editDlg) { KAEvent event; Resource resource; editDlg->getEvent(event, resource); // Add the alarm to the displayed lists and to the calendar file const UpdateResult status = addEvent(event, &resource, editDlg); switch (status.status) { case UPDATE_FAILED: return; case UPDATE_KORG_ERR: case UPDATE_KORG_ERRINIT: case UPDATE_KORG_ERRSTART: case UPDATE_KORG_FUNCERR: displayKOrgUpdateError(editDlg, ERR_ADD, status); break; default: break; } Undo::saveAdd(event, resource); outputAlarmWarnings(editDlg, &event); editDlg->deleteLater(); } /****************************************************************************** * Called when the dialogue is rejected (e.g. by clicking the Cancel button). */ void PrivateNewAlarmDlg::cancelClicked() { static_cast(parent())->deleteLater(); } /****************************************************************************** * Display the alarm edit dialog to edit a new alarm, preset with a template. */ bool editNewAlarm(const QString& templateName, QWidget* parent) { if (!templateName.isEmpty()) { KAEvent* templateEvent = ResourcesCalendar::instance()->templateEvent(templateName); if (templateEvent->isValid()) { editNewAlarm(templateEvent, parent); return true; } qCWarning(KALARM_LOG) << "KAlarm::editNewAlarm:" << templateName << ": template not found"; } return false; } /****************************************************************************** * Create a new template. */ void editNewTemplate(EditAlarmDlg::Type type, QWidget* parent) { ::editNewTemplate(type, nullptr, parent); } /****************************************************************************** * Create a new template, based on an existing event or template. */ void editNewTemplate(const KAEvent* preset, QWidget* parent) { ::editNewTemplate(EditAlarmDlg::Type(0), preset, parent); } /****************************************************************************** * Check the config as to whether there is a wake-on-suspend alarm pending, and * if so, delete it from the config if it has expired. * If 'checkExists' is true, the config entry will only be returned if the * event exists. * Reply = config entry: [0] = event's resource ID, * [1] = event ID, * [2] = trigger time (int64 seconds since epoch). * = empty list if none or expired. */ QStringList checkRtcWakeConfig(bool checkEventExists) { KConfigGroup config(KSharedConfig::openConfig(), "General"); const QStringList params = config.readEntry("RtcWake", QStringList()); #if KALARMCAL_VERSION >= QT_VERSION_CHECK(5,12,1) if (params.count() == 3 && params[2].toLongLong() > KADateTime::currentUtcDateTime().toSecsSinceEpoch()) #else if (params.count() == 3 && params[2].toUInt() > KADateTime::currentUtcDateTime().toTime_t()) #endif { if (checkEventExists && !ResourcesCalendar::getEvent(EventId(params[0].toLongLong(), params[1]))) return QStringList(); return params; // config entry is valid } if (!params.isEmpty()) { config.deleteEntry("RtcWake"); // delete the expired config entry config.sync(); } return QStringList(); } /****************************************************************************** * Delete any wake-on-suspend alarm from the config. */ void deleteRtcWakeConfig() { KConfigGroup config(KSharedConfig::openConfig(), "General"); config.deleteEntry("RtcWake"); config.sync(); } /****************************************************************************** * Delete any wake-on-suspend alarm, optionally only for a specified event. */ void cancelRtcWake(QWidget* msgParent, const QString& eventId) { const QStringList wakeup = checkRtcWakeConfig(); if (!wakeup.isEmpty() && (eventId.isEmpty() || wakeup[0] == eventId)) { Private::instance()->mMsgParent = msgParent ? msgParent : MainWindow::mainMainWindow(); QTimer::singleShot(0, Private::instance(), &Private::cancelRtcWake); } } /****************************************************************************** * Delete any wake-on-suspend alarm. */ void Private::cancelRtcWake() { // setRtcWakeTime will only work with a parent window specified setRtcWakeTime(0, mMsgParent); deleteRtcWakeConfig(); KAMessageBox::information(mMsgParent, i18nc("info", "The scheduled Wake from Suspend has been cancelled.")); } /****************************************************************************** * Set the wakeup time for the system. * Set 'triggerTime' to zero to cancel the wakeup. * Reply = true if successful. */ bool setRtcWakeTime(unsigned triggerTime, QWidget* parent) { QVariantMap args; args[QStringLiteral("time")] = triggerTime; KAuth::Action action(QStringLiteral("org.kde.kalarm.rtcwake.settimer")); action.setHelperId(QStringLiteral("org.kde.kalarm.rtcwake")); action.setParentWidget(parent); action.setArguments(args); KAuth::ExecuteJob* job = action.execute(); if (!job->exec()) { QString errmsg = job->errorString(); qCDebug(KALARM_LOG) << "KAlarm::setRtcWakeTime: Error code=" << job->error() << errmsg; if (errmsg.isEmpty()) { int errcode = job->error(); switch (errcode) { case KAuth::ActionReply::AuthorizationDeniedError: case KAuth::ActionReply::UserCancelledError: qCDebug(KALARM_LOG) << "KAlarm::setRtcWakeTime: Authorization error:" << errcode; return false; // the user should already know about this default: break; } errmsg = i18nc("@info", "Error obtaining authorization (%1)", errcode); } KAMessageBox::information(parent, errmsg); return false; } return true; } } // namespace KAlarm namespace { /****************************************************************************** * Create a new template. * 'preset' is non-null to base it on an existing event or template; otherwise, * the alarm type is set to 'type'. */ void editNewTemplate(EditAlarmDlg::Type type, const KAEvent* preset, QWidget* parent) { if (Resources::enabledResources(CalEvent::TEMPLATE, true).isEmpty()) { KAMessageBox::sorry(parent, i18nc("@info", "You must enable a template calendar to save the template in")); return; } // Use AutoQPointer to guard against crash on application exit while // the dialogue is still open. It prevents double deletion (both on // deletion of parent, and on return from this function). AutoQPointer editDlg; if (preset) editDlg = EditAlarmDlg::create(true, preset, true, parent); else editDlg = EditAlarmDlg::create(true, type, parent); if (editDlg->exec() == QDialog::Accepted) { KAEvent event; Resource resource; editDlg->getEvent(event, resource); // Add the template to the displayed lists and to the calendar file KAlarm::addTemplate(event, &resource, editDlg); Undo::saveAdd(event, resource); } } } // namespace namespace KAlarm { /****************************************************************************** * Open the Edit Alarm dialog to edit the specified alarm. * If the alarm is read-only or archived, the dialog is opened read-only. */ void editAlarm(KAEvent* event, QWidget* parent) { if (event->expired() || ResourcesCalendar::instance()->eventReadOnly(event->id())) { viewAlarm(event, parent); return; } const EventId id(*event); // Use AutoQPointer to guard against crash on application exit while // the dialogue is still open. It prevents double deletion (both on // deletion of parent, and on return from this function). AutoQPointer editDlg = EditAlarmDlg::create(false, event, false, parent, EditAlarmDlg::RES_USE_EVENT_ID); if (editDlg->exec() == QDialog::Accepted) { if (!ResourcesCalendar::instance()->event(id)) { // Event has been deleted while the user was editing the alarm, // so treat it as a new alarm. PrivateNewAlarmDlg().accept(editDlg); return; } KAEvent newEvent; Resource resource; bool changeDeferral = !editDlg->getEvent(newEvent, resource); // Update the event in the displays and in the calendar file const Undo::Event undo(*event, resource); if (changeDeferral) { // The only change has been to an existing deferral if (updateEvent(newEvent, editDlg, true) != UPDATE_OK) // keep the same event ID return; // failed to save event } else { const UpdateResult status = modifyEvent(*event, newEvent, editDlg); if (status.status != UPDATE_OK && status.status <= UPDATE_KORG_ERR) displayKOrgUpdateError(editDlg, ERR_MODIFY, status); } Undo::saveEdit(undo, newEvent); outputAlarmWarnings(editDlg, &newEvent); } } /****************************************************************************** * Display the alarm edit dialog to edit the alarm with the specified ID. * An error occurs if the alarm is not found, if there is more than one alarm * with the same ID, or if it is read-only or expired. */ bool editAlarmById(const EventId& id, QWidget* parent) { const QString eventID(id.eventId()); KAEvent* event = ResourcesCalendar::instance()->event(id, true); if (!event) { if (id.resourceId() != -1) qCWarning(KALARM_LOG) << "KAlarm::editAlarmById: Event ID not found, or duplicated:" << eventID; else qCWarning(KALARM_LOG) << "KAlarm::editAlarmById: Event ID not found:" << eventID; return false; } if (ResourcesCalendar::instance()->eventReadOnly(event->id())) { qCCritical(KALARM_LOG) << "KAlarm::editAlarmById:" << eventID << ": read-only"; return false; } switch (event->category()) { case CalEvent::ACTIVE: case CalEvent::TEMPLATE: break; default: qCCritical(KALARM_LOG) << "KAlarm::editAlarmById:" << eventID << ": event not active or template"; return false; } editAlarm(event, parent); return true; } /****************************************************************************** * Open the Edit Alarm dialog to edit the specified template. * If the template is read-only, the dialog is opened read-only. */ void editTemplate(KAEvent* event, QWidget* parent) { if (ResourcesCalendar::instance()->eventReadOnly(event->id())) { // The template is read-only, so make the dialogue read-only. // Use AutoQPointer to guard against crash on application exit while // the dialogue is still open. It prevents double deletion (both on // deletion of parent, and on return from this function). AutoQPointer editDlg = EditAlarmDlg::create(true, event, false, parent, EditAlarmDlg::RES_PROMPT, true); editDlg->exec(); return; } // Use AutoQPointer to guard against crash on application exit while // the dialogue is still open. It prevents double deletion (both on // deletion of parent, and on return from this function). AutoQPointer editDlg = EditAlarmDlg::create(true, event, false, parent, EditAlarmDlg::RES_USE_EVENT_ID); if (editDlg->exec() == QDialog::Accepted) { KAEvent newEvent; Resource resource; editDlg->getEvent(newEvent, resource); const QString id = event->id(); newEvent.setEventId(id); newEvent.setResourceId(event->resourceId()); // Update the event in the displays and in the calendar file const Undo::Event undo(*event, resource); updateTemplate(newEvent, editDlg); Undo::saveEdit(undo, newEvent); } } /****************************************************************************** * Open the Edit Alarm dialog to view the specified alarm (read-only). */ void viewAlarm(const KAEvent* event, QWidget* parent) { // Use AutoQPointer to guard against crash on application exit while // the dialogue is still open. It prevents double deletion (both on // deletion of parent, and on return from this function). AutoQPointer editDlg = EditAlarmDlg::create(false, event, false, parent, EditAlarmDlg::RES_PROMPT, true); editDlg->exec(); } /****************************************************************************** * Called when OK is clicked in the alarm edit dialog invoked by the Edit button * in an alarm message window. * Updates the alarm calendar and closes the dialog. */ void updateEditedAlarm(EditAlarmDlg* editDlg, KAEvent& event, Resource& resource) { qCDebug(KALARM_LOG) << "KAlarm::updateEditedAlarm"; KAEvent newEvent; Resource res; editDlg->getEvent(newEvent, res); // Update the displayed lists and the calendar file UpdateResult status; if (ResourcesCalendar::instance()->event(EventId(event))) { // The old alarm hasn't expired yet, so replace it const Undo::Event undo(event, resource); status = modifyEvent(event, newEvent, editDlg); Undo::saveEdit(undo, newEvent); } else { // The old event has expired, so simply create a new one status = addEvent(newEvent, &resource, editDlg); Undo::saveAdd(newEvent, resource); } if (status.status != UPDATE_OK && status.status <= UPDATE_KORG_ERR) displayKOrgUpdateError(editDlg, ERR_MODIFY, status); outputAlarmWarnings(editDlg, &newEvent); editDlg->close(); } /****************************************************************************** * Returns a list of all alarm templates. * If shell commands are disabled, command alarm templates are omitted. */ KAEvent::List templateList() { KAEvent::List templates; const bool includeCmdAlarms = ShellProcess::authorised(); const KAEvent::List events = ResourcesCalendar::instance()->events(CalEvent::TEMPLATE); for (KAEvent* event : events) { if (includeCmdAlarms || !(event->actionTypes() & KAEvent::ACT_COMMAND)) templates.append(event); } return templates; } /****************************************************************************** * To be called after an alarm has been edited. * Prompt the user to re-enable alarms if they are currently disabled, and if * it's an email alarm, warn if no 'From' email address is configured. */ void outputAlarmWarnings(QWidget* parent, const KAEvent* event) { if (event && event->actionTypes() == KAEvent::ACT_EMAIL && Preferences::emailAddress().isEmpty()) KAMessageBox::information(parent, xi18nc("@info Please set the 'From' email address...", "%1Please set it in the Configuration dialog.", KAMail::i18n_NeedFromEmailAddress())); if (!theApp()->alarmsEnabled()) { if (KAMessageBox::warningYesNo(parent, xi18nc("@info", "Alarms are currently disabled.Do you want to enable alarms now?"), QString(), KGuiItem(i18nc("@action:button", "Enable")), KGuiItem(i18nc("@action:button", "Keep Disabled")), QStringLiteral("EditEnableAlarms")) == KMessageBox::Yes) theApp()->setAlarmsEnabled(true); } } /****************************************************************************** * Reload the calendar. */ void refreshAlarms() { qCDebug(KALARM_LOG) << "KAlarm::refreshAlarms"; if (!refreshAlarmsQueued) { refreshAlarmsQueued = true; theApp()->processQueue(); } } /****************************************************************************** * This method must only be called from the main KAlarm queue processing loop, * to prevent asynchronous calendar operations interfering with one another. * * If refreshAlarms() has been called, reload the calendars. */ void refreshAlarmsIfQueued() { if (refreshAlarmsQueued) { qCDebug(KALARM_LOG) << "KAlarm::refreshAlarmsIfQueued"; ResourcesCalendar::instance()->reload(); // Close any message windows for alarms which are now disabled const KAEvent::List events = ResourcesCalendar::instance()->events(CalEvent::ACTIVE); for (KAEvent* event : events) { if (!event->enabled() && (event->actionTypes() & KAEvent::ACT_DISPLAY)) { MessageWin* win = MessageWin::findEvent(EventId(*event)); delete win; } } MainWindow::refresh(); refreshAlarmsQueued = false; } } /****************************************************************************** * Start KMail if it isn't already running, optionally minimised. * Reply = reason for failure to run KMail * = null string if success. */ QString runKMail() { const QDBusReply reply = QDBusConnection::sessionBus().interface()->isServiceRegistered(KMAIL_DBUS_SERVICE); if (!reply.isValid() || !reply.value()) { // Program is not already running, so start it const QDBusReply startReply = QDBusConnection::sessionBus().interface()->startService(KMAIL_DBUS_SERVICE); if (!startReply.isValid()) { const QString errmsg = startReply.error().message(); qCCritical(KALARM_LOG) << "Couldn't start KMail (" << errmsg << ")"; return xi18nc("@info", "Unable to start KMail(%1)", errmsg); } } return QString(); } /****************************************************************************** * The "Don't show again" option for error messages is personal to the user on a * particular computer. For example, he may want to inhibit error messages only * on his laptop. So the status is not stored in the alarm calendar, but in the * user's local KAlarm data directory. ******************************************************************************/ /****************************************************************************** * Return the Don't-show-again error message tags set for a specified alarm ID. */ QStringList dontShowErrors(const EventId& eventId) { if (eventId.isEmpty()) return QStringList(); KConfig config(QStandardPaths::writableLocation(QStandardPaths::DataLocation) + QLatin1Char('/') + ALARM_OPTS_FILE); KConfigGroup group(&config, DONT_SHOW_ERRORS_GROUP); const QString id = QStringLiteral("%1:%2").arg(eventId.resourceId()).arg(eventId.eventId()); return group.readEntry(id, QStringList()); } /****************************************************************************** * Check whether the specified Don't-show-again error message tag is set for an * alarm ID. */ bool dontShowErrors(const EventId& eventId, const QString& tag) { if (tag.isEmpty()) return false; const QStringList tags = dontShowErrors(eventId); return tags.indexOf(tag) >= 0; } /****************************************************************************** * Reset the Don't-show-again error message tags for an alarm ID. * If 'tags' is empty, the config entry is deleted. */ void setDontShowErrors(const EventId& eventId, const QStringList& tags) { if (eventId.isEmpty()) return; KConfig config(QStandardPaths::writableLocation(QStandardPaths::DataLocation) + QLatin1Char('/') + ALARM_OPTS_FILE); KConfigGroup group(&config, DONT_SHOW_ERRORS_GROUP); const QString id = QStringLiteral("%1:%2").arg(eventId.resourceId()).arg(eventId.eventId()); if (tags.isEmpty()) group.deleteEntry(id); else group.writeEntry(id, tags); group.sync(); } /****************************************************************************** * Set the specified Don't-show-again error message tag for an alarm ID. * Existing tags are unaffected. */ void setDontShowErrors(const EventId& eventId, const QString& tag) { if (eventId.isEmpty() || tag.isEmpty()) return; KConfig config(QStandardPaths::writableLocation(QStandardPaths::DataLocation) + QLatin1Char('/') + ALARM_OPTS_FILE); KConfigGroup group(&config, DONT_SHOW_ERRORS_GROUP); const QString id = QStringLiteral("%1:%2").arg(eventId.resourceId()).arg(eventId.eventId()); QStringList tags = group.readEntry(id, QStringList()); if (tags.indexOf(tag) < 0) { tags += tag; group.writeEntry(id, tags); group.sync(); } } /****************************************************************************** * Convert a date/time specification string into a local date/time or date value. * Parameters: * timeString = in the form [[[yyyy-]mm-]dd-]hh:mm [TZ] or yyyy-mm-dd [TZ]. * dateTime = receives converted date/time value. * defaultDt = default date/time used for missing parts of timeString, or null * to use current date/time. * allowTZ = whether to allow a time zone specifier in timeString. * Reply = true if successful. */ bool convertTimeString(const QByteArray& timeString, KADateTime& dateTime, const KADateTime& defaultDt, bool allowTZ) { #define MAX_DT_LEN 19 int i = timeString.indexOf(' '); if (i > MAX_DT_LEN || (i >= 0 && !allowTZ)) return false; QString zone = (i >= 0) ? QString::fromLatin1(timeString.mid(i)) : QString(); char timeStr[MAX_DT_LEN+1]; strcpy(timeStr, timeString.left(i >= 0 ? i : MAX_DT_LEN).constData()); int dt[5] = { -1, -1, -1, -1, -1 }; char* s; char* end; bool noTime; // Get the minute value if ((s = strchr(timeStr, ':')) == nullptr) noTime = true; else { noTime = false; *s++ = 0; dt[4] = strtoul(s, &end, 10); if (end == s || *end || dt[4] >= 60) return false; // Get the hour value if ((s = strrchr(timeStr, '-')) == nullptr) s = timeStr; else *s++ = 0; dt[3] = strtoul(s, &end, 10); if (end == s || *end || dt[3] >= 24) return false; } bool noDate = true; if (s != timeStr) { noDate = false; // Get the day value if ((s = strrchr(timeStr, '-')) == nullptr) s = timeStr; else *s++ = 0; dt[2] = strtoul(s, &end, 10); if (end == s || *end || dt[2] == 0 || dt[2] > 31) return false; if (s != timeStr) { // Get the month value if ((s = strrchr(timeStr, '-')) == nullptr) s = timeStr; else *s++ = 0; dt[1] = strtoul(s, &end, 10); if (end == s || *end || dt[1] == 0 || dt[1] > 12) return false; if (s != timeStr) { // Get the year value dt[0] = strtoul(timeStr, &end, 10); if (end == timeStr || *end) return false; } } } QDate date; if (dt[0] >= 0) date = QDate(dt[0], dt[1], dt[2]); QTime time(0, 0, 0); if (noTime) { // No time was specified, so the full date must have been specified if (dt[0] < 0 || !date.isValid()) return false; dateTime = applyTimeZone(zone, date, time, false, defaultDt); } else { // Compile the values into a date/time structure time.setHMS(dt[3], dt[4], 0); if (dt[0] < 0) { // Some or all of the date was omitted. // Use the default date/time if provided. if (defaultDt.isValid()) { dt[0] = defaultDt.date().year(); date.setDate(dt[0], (dt[1] < 0 ? defaultDt.date().month() : dt[1]), (dt[2] < 0 ? defaultDt.date().day() : dt[2])); } else date.setDate(2000, 1, 1); // temporary substitute for date } dateTime = applyTimeZone(zone, date, time, true, defaultDt); if (!dateTime.isValid()) return false; if (dt[0] < 0) { // Some or all of the date was omitted. // Use the current date in the specified time zone as default. const KADateTime now = KADateTime::currentDateTime(dateTime.timeSpec()); date = dateTime.date(); date.setDate(now.date().year(), (dt[1] < 0 ? now.date().month() : dt[1]), (dt[2] < 0 ? now.date().day() : dt[2])); if (!date.isValid()) return false; if (noDate && time < now.time()) date = date.addDays(1); dateTime.setDate(date); } } return dateTime.isValid(); } /****************************************************************************** * Convert a time zone specifier string and apply it to a given date and/or time. * The time zone specifier is a system time zone name, e.g. "Europe/London" or * "UTC". If no time zone is specified, it defaults to the local time zone. * If 'defaultDt' is valid, it supplies the time spec and default date. */ KADateTime applyTimeZone(const QString& tzstring, const QDate& date, const QTime& time, bool haveTime, const KADateTime& defaultDt) { bool error = false; KADateTime::Spec spec = KADateTime::LocalZone; const QString zone = tzstring.trimmed(); if (!zone.isEmpty()) { if (zone == QLatin1String("UTC")) spec = KADateTime::UTC; else { const QTimeZone tz(zone.toLatin1()); error = !tz.isValid(); if (!error) spec = tz; } } else if (defaultDt.isValid()) spec = defaultDt.timeSpec(); KADateTime result; if (!error) { if (!date.isValid()) { // It's a time without a date if (defaultDt.isValid()) result = KADateTime(defaultDt.date(), time, spec); else if (spec == KADateTime::LocalZone) result = KADateTime(KADateTime::currentLocalDate(), time, spec); } else if (haveTime) { // It's a date and time result = KADateTime(date, time, spec); } else { // It's a date without a time result = KADateTime(date, spec); } } return result; } // vim: et sw=4: #ifndef NDEBUG /****************************************************************************** * Set up KAlarm test conditions based on environment variables. * KALARM_TIME: specifies current system time (format [[[yyyy-]mm-]dd-]hh:mm [TZ]). */ void setTestModeConditions() { const QByteArray newTime = qgetenv("KALARM_TIME"); if (!newTime.isEmpty()) { KADateTime dt; if (convertTimeString(newTime, dt, KADateTime::realCurrentLocalDateTime(), true)) setSimulatedSystemTime(dt); } } /****************************************************************************** * Set the simulated system time. */ void setSimulatedSystemTime(const KADateTime& dt) { KADateTime::setSimulatedSystemTime(dt); qCDebug(KALARM_LOG) << "New time =" << qPrintable(KADateTime::currentLocalDateTime().toString(QStringLiteral("%Y-%m-%d %H:%M %:Z"))); } #endif } // namespace KAlarm namespace { /****************************************************************************** * Display an error message about an error when saving an event. */ void displayUpdateError(QWidget* parent, KAlarm::UpdateError code, const UpdateStatusData& status, bool showKOrgError) { QString errmsg; if (status.status.status > KAlarm::UPDATE_KORG_ERR) { switch (code) { case KAlarm::ERR_ADD: case KAlarm::ERR_MODIFY: errmsg = (status.warnErr > 1) ? i18nc("@info", "Error saving alarms") : i18nc("@info", "Error saving alarm"); break; case KAlarm::ERR_DELETE: errmsg = (status.warnErr > 1) ? i18nc("@info", "Error deleting alarms") : i18nc("@info", "Error deleting alarm"); break; case KAlarm::ERR_REACTIVATE: errmsg = (status.warnErr > 1) ? i18nc("@info", "Error saving reactivated alarms") : i18nc("@info", "Error saving reactivated alarm"); break; case KAlarm::ERR_TEMPLATE: errmsg = (status.warnErr > 1) ? i18nc("@info", "Error saving alarm templates") : i18nc("@info", "Error saving alarm template"); break; } KAMessageBox::error(parent, errmsg); } else if (showKOrgError) displayKOrgUpdateError(parent, code, status.status, status.warnKOrg); } /****************************************************************************** * Tell KOrganizer to put an alarm in its calendar. * It will be held by KOrganizer as a simple event, without alarms - KAlarm * is still responsible for alarming. */ KAlarm::UpdateResult sendToKOrganizer(const KAEvent& event) { Event::Ptr kcalEvent(new KCalendarCore::Event); event.updateKCalEvent(kcalEvent, KAEvent::UID_IGNORE); // Change the event ID to avoid duplicating the same unique ID as the original event const QString uid = uidKOrganizer(event.id()); kcalEvent->setUid(uid); kcalEvent->clearAlarms(); QString userEmail; switch (event.actionTypes()) { case KAEvent::ACT_DISPLAY: case KAEvent::ACT_COMMAND: case KAEvent::ACT_DISPLAY_COMMAND: kcalEvent->setSummary(event.cleanText()); userEmail = Preferences::emailAddress(); break; case KAEvent::ACT_EMAIL: { const QString from = event.emailFromId() ? Identities::identityManager()->identityForUoid(event.emailFromId()).fullEmailAddr() : Preferences::emailAddress(); AlarmText atext; atext.setEmail(event.emailAddresses(QStringLiteral(", ")), from, QString(), QString(), event.emailSubject(), QString()); kcalEvent->setSummary(atext.displayText()); userEmail = from; break; } case KAEvent::ACT_AUDIO: kcalEvent->setSummary(event.audioFile()); break; default: break; } const Person person(QString(), userEmail); kcalEvent->setOrganizer(person); kcalEvent->setDuration(Duration(Preferences::kOrgEventDuration() * 60, Duration::Seconds)); // Translate the event into string format ICalFormat format; format.setTimeZone(Preferences::timeSpecAsZone()); const QString iCal = format.toICalString(kcalEvent); // Send the event to KOrganizer KAlarm::UpdateResult status = runKOrganizer(); // start KOrganizer if it isn't already running, and create its D-Bus interface if (status != KAlarm::UPDATE_OK) return status; QDBusInterface korgInterface(KORG_DBUS_SERVICE, QStringLiteral(KORG_DBUS_PATH), KORG_DBUS_IFACE); const QList args{iCal}; QDBusReply reply = korgInterface.callWithArgumentList(QDBus::Block, QStringLiteral("addIncidence"), args); if (!reply.isValid()) { if (reply.error().type() == QDBusError::UnknownObject) { status = KAlarm::UPDATE_KORG_ERRSTART; qCCritical(KALARM_LOG) << "KAlarm::sendToKOrganizer: addIncidence() D-Bus error: still starting"; } else { status.set(KAlarm::UPDATE_KORG_ERR, reply.error().message()); qCCritical(KALARM_LOG) << "KAlarm::sendToKOrganizer: addIncidence(" << uid << ") D-Bus call failed:" << status.message; } } else if (!reply.value()) { status = KAlarm::UPDATE_KORG_FUNCERR; qCDebug(KALARM_LOG) << "KAlarm::sendToKOrganizer: addIncidence(" << uid << ") D-Bus call returned false"; } else qCDebug(KALARM_LOG) << "KAlarm::sendToKOrganizer:" << uid << ": success"; return status; } /****************************************************************************** * Tell KOrganizer to delete an event from its calendar. */ KAlarm::UpdateResult deleteFromKOrganizer(const QString& eventID) { const QString newID = uidKOrganizer(eventID); new AkonadiCollectionSearch(KORG_MIME_TYPE, QString(), newID, true); // this auto-deletes when complete // Ignore errors return KAlarm::UpdateResult(KAlarm::UPDATE_OK); } /****************************************************************************** * Start KOrganizer if not already running, and create its D-Bus interface. */ KAlarm::UpdateResult runKOrganizer() { KAlarm::UpdateResult status; // If Kontact is running, there is a load() method which needs to be called to // load KOrganizer into Kontact. But if KOrganizer is running independently, // the load() method doesn't exist. This call starts korganizer if needed, too. QDBusInterface iface(KORG_DBUS_SERVICE, QStringLiteral(KORG_DBUS_LOAD_PATH), QStringLiteral("org.kde.PIMUniqueApplication")); QDBusReply reply = iface.call(QStringLiteral("load")); if ((!reply.isValid() || !reply.value()) && iface.lastError().type() != QDBusError::UnknownMethod) { status.set(KAlarm::UPDATE_KORG_ERR, iface.lastError().message()); qCWarning(KALARM_LOG) << "Loading KOrganizer failed:" << status.message; return status; } return status; } /****************************************************************************** * Insert a KOrganizer string after the hyphen in the supplied event ID. */ QString uidKOrganizer(const QString& id) { if (id.startsWith(KORGANIZER_UID)) return id; QString result = id; return result.insert(0, KORGANIZER_UID); } } // namespace /****************************************************************************** * Case insensitive comparison for use by qSort(). */ bool caseInsensitiveLessThan(const QString& s1, const QString& s2) { return s1.toLower() < s2.toLower(); } // vim: et sw=4: diff --git a/src/resources/dirresourceimportdialog.cpp b/src/resources/dirresourceimportdialog.cpp index f2584ce6..0e09de26 100644 --- a/src/resources/dirresourceimportdialog.cpp +++ b/src/resources/dirresourceimportdialog.cpp @@ -1,510 +1,510 @@ /* * dirresourceimportdialog.cpp - configuration dialog to import directory resources * Program: kalarm * Copyright © 2020 David Jarvie * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "dirresourceimportdialog.h" #include "dirresourceimportdialog_p.h" #include "ui_dirresourceimportdialog_intro.h" #include "ui_dirresourceimportdialog_type.h" #include "resources.h" #include "fileresource.h" #include #include #include #include #include #include using namespace KAlarmCal; /****************************************************************************** * Constructor. */ DirResourceImportDialog::DirResourceImportDialog(const QString& dirResourceName, const QString& dirResourcePath, KAlarmCal::CalEvent::Types types, QWidget* parent) : KAssistantDialog(parent) , mAlarmTypes(types) { setWindowTitle(i18nc("@title:window", "Import Directory Resource")); // Remove Help button buttonBox()->removeButton(button(QDialogButtonBox::Help)); mPageIntro = new DirResourceImportIntroWidget(dirResourceName, dirResourcePath, types, this); addPage(mPageIntro, i18nc("@title:tab", "Import Calendar Directory Resource")); mAlarmTypeCount = 0; if (mAlarmTypes & CalEvent::ACTIVE) { ++mAlarmTypeCount; mPageActive = new DirResourceImportTypeWidget(CalEvent::ACTIVE, this); addPage(mPageActive, i18nc("@title:tab", "Import Active Alarms")); connect(mPageActive, &DirResourceImportTypeWidget::status, this, &DirResourceImportDialog::typeStatusChanged); mLastPage = mPageActive; } if (mAlarmTypes & CalEvent::ARCHIVED) { ++mAlarmTypeCount; mPageArchived = new DirResourceImportTypeWidget(CalEvent::ARCHIVED, this); addPage(mPageArchived, i18nc("@title:tab", "Import Archived Alarms")); connect(mPageArchived, &DirResourceImportTypeWidget::status, this, &DirResourceImportDialog::typeStatusChanged); mLastPage = mPageArchived; } if (mAlarmTypes & CalEvent::TEMPLATE) { ++mAlarmTypeCount; mPageTemplate = new DirResourceImportTypeWidget(CalEvent::TEMPLATE, this); addPage(mPageTemplate, i18nc("@title:tab", "Import Alarm Templates")); connect(mPageTemplate, &DirResourceImportTypeWidget::status, this, &DirResourceImportDialog::typeStatusChanged); mLastPage = mPageTemplate; } connect(this, &KPageDialog::currentPageChanged, this, &DirResourceImportDialog::pageChanged); } DirResourceImportDialog::~DirResourceImportDialog() { } /****************************************************************************** * Return the existing resource to import into, for a specified alarm type. */ ResourceId DirResourceImportDialog::resourceId(KAlarmCal::CalEvent::Type type) const { const DirResourceImportTypeWidget* page = typePage(type); return page ? page->resourceId() : -1; } /****************************************************************************** * Return the new calendar file URL, for a specified alarm type. */ QUrl DirResourceImportDialog::url(KAlarmCal::CalEvent::Type type) const { const DirResourceImportTypeWidget* page = typePage(type); return page ? page->url() : QUrl(); } /****************************************************************************** * Return the resource's display name, for a specified alarm type. */ QString DirResourceImportDialog::displayName(KAlarmCal::CalEvent::Type type) const { const DirResourceImportTypeWidget* page = typePage(type); return page ? page->displayName() : QString(); } /****************************************************************************** * Set a validation function to apply to an entered URL. */ void DirResourceImportDialog::setUrlValidation(QString (*func)(const QUrl&)) { if (mPageActive) mPageActive->setUrlValidation(func); if (mPageArchived) mPageArchived->setUrlValidation(func); if (mPageTemplate) mPageTemplate->setUrlValidation(func); } /****************************************************************************** * When a new page is displayed, set appropriate heights for elements within the * page, and enable/disable elements according to their status. */ void DirResourceImportDialog::pageChanged(KPageWidgetItem* current, KPageWidgetItem* before) { Q_UNUSED(before); if (current) { DirResourceImportWidgetBase* page = static_cast(current->widget()); page->setTextSizes(); DirResourceImportTypeWidget* typePage = qobject_cast(page); if (typePage) typePage->validate(); } } /****************************************************************************** * Called when the data entered into an alarm type import page has changed. * Enable or disable the Next button, depending on whether the entered data is * valid or not. */ void DirResourceImportDialog::typeStatusChanged(bool ok) { DirResourceImportTypeWidget* page = qobject_cast(currentPage()->widget()); if (page) { nextButton()->setEnabled(ok && (page != mLastPage)); finishButton()->setEnabled(ok && (page == mLastPage)); } } const DirResourceImportTypeWidget* DirResourceImportDialog::typePage(KAlarmCal::CalEvent::Type type) const { if (mAlarmTypes & type) { switch (type) { case CalEvent::ACTIVE: return mPageActive; case CalEvent::ARCHIVED: return mPageArchived; case CalEvent::TEMPLATE: return mPageTemplate; default: break; } } return nullptr; } /*============================================================================= = Class DirResourceImportWidgetBase = Base class for page widgets. =============================================================================*/ DirResourceImportWidgetBase::DirResourceImportWidgetBase(QWidget* parent) : QWidget(parent) { } /*============================================================================= = Class DirResourceImportIntroWidget = The first page of the directory resource import dialog, which gives general = information to the user. =============================================================================*/ DirResourceImportIntroWidget::DirResourceImportIntroWidget(const QString& dirResourceName, const QString& dirResourcePath, KAlarmCal::CalEvent::Types types, QWidget* parent) : DirResourceImportWidgetBase(parent) { mUi = new Ui_DirResourceImportIntroWidget; mUi->setupUi(this); mUi->dirNameLabel->setText(dirResourceName); mUi->dirPathLabel->setText(dirResourcePath); QStringList typeNames; if (types & CalEvent::ACTIVE) typeNames += i18nc("@item:intext", "Active alarms"); if (types & CalEvent::ARCHIVED) typeNames += i18nc("@item:intext", "Archived alarms"); if (types & CalEvent::TEMPLATE) typeNames += i18nc("@item:intext", "Alarm templates"); mUi->dirTypesLabel->setText(typeNames.join(QStringLiteral(", "))); if (typeNames.size() > 1) mUi->warning1->setVisible(false); else mUi->warning2->setVisible(false); } DirResourceImportIntroWidget::~DirResourceImportIntroWidget() { delete mUi; } /****************************************************************************** * Called when the page is displayed, to set appropriate heights for QLabel * elements with text wrapping, and then remove empty space between widgets. * By default, if QLabel contains more than one line of text, it often occupies * more space than required, and calling setMinimumHeight() doesn't affect this. */ void DirResourceImportIntroWidget::setTextSizes() { mUi->warning1->setFixedHeight(mUi->warning1->height()); mUi->warning2->setFixedHeight(mUi->warning2->height()); mUi->note->setFixedHeight(mUi->note->height()); setFixedHeight(sizeHint().height()); } /*============================================================================= = Class DirResourceImportTypeWidget = The page of the directory resource import dialog which allows the user to = specify how to import one alarm type. =============================================================================*/ DirResourceImportTypeWidget::DirResourceImportTypeWidget(CalEvent::Type alarmType, QWidget* parent) : DirResourceImportWidgetBase(parent) { mUi = new Ui_DirResourceImportTypeWidget; mUi->setupUi(this); const QVector resources = Resources::allResources(alarmType, Resources::DefaultFirst | Resources::DisplayName); if (resources.isEmpty()) { mUi->mergeRadio->setVisible(false); mUi->mergeRadio->setEnabled(false); mUi->mergeResource->setVisible(false); } else { for (const Resource& resource : resources) mUi->mergeResource->addItem(resource.displayName(), QVariant(resource.id())); } connect(mUi->optionGroup, QOverload::of(&QButtonGroup::buttonToggled), this, &DirResourceImportTypeWidget::importTypeSelected); mUi->pathRequester->setMode(KFile::File); - mUi->pathRequester->setFilter(QStringLiteral("*.ics|%1").arg(i18nc("@item:inlistbox File type selection filter", "Calendar Files"))); + mUi->pathRequester->setFilter(QStringLiteral("*.ics|%1").arg(i18nc("@item:inlistbox File type selection filter", "Calendar files"))); mUi->statusLabel->setText(QString()); mUi->pathRequester->setFocus(); mUi->pathRequester->installEventFilter(this); connect(mUi->pathRequester, QOverload<>::of(&KUrlRequester::returnPressed), this, [this]() { validate(); }); connect(mUi->pathRequester, &KUrlRequester::urlSelected, this, [this]() { validate(); }); connect(mUi->pathRequester, &KUrlRequester::textChanged, this, [this]() { setStatus(false); }); connect(mUi->nameText, &QLineEdit::textChanged, this, [this]() { validate(); }); // Indent fields beneath each radio button option. QRadioButton radio(this); QStyleOptionButton opt; opt.initFrom(&radio); int indentWidth = style()->subElementRect(QStyle::SE_RadioButtonIndicator, &opt).width(); mUi->grid->setColumnMinimumWidth(0, indentWidth); mUi->grid->setColumnStretch(1, 1); importTypeSelected(); QTimer::singleShot(0, this, &DirResourceImportTypeWidget::validate); } DirResourceImportTypeWidget::~DirResourceImportTypeWidget() { delete mUi; } /****************************************************************************** * Return the existing resource ID to import into. */ ResourceId DirResourceImportTypeWidget::resourceId() const { return mUi->mergeRadio->isChecked() ? mUi->mergeResource->currentData().toLongLong() : -1; } /****************************************************************************** * Return the new calendar file URL. */ QUrl DirResourceImportTypeWidget::url() const { return mUi->newRadio->isChecked() ? mUi->pathRequester->url() : QUrl(); } /****************************************************************************** * Return the resource's display name. */ QString DirResourceImportTypeWidget::displayName() const { return mUi->newRadio->isChecked() ? mUi->nameText->text() : QString(); } /****************************************************************************** * Notify the page that it is the last page. */ void DirResourceImportTypeWidget::setLastPage() { mLastPage = true; } /****************************************************************************** * Set a validation function to apply to an entered URL. */ void DirResourceImportTypeWidget::setUrlValidation(QString (*func)(const QUrl&)) { mUrlValidationFunc = func; } /****************************************************************************** * Called when the page is displayed, to set appropriate heights for QLabel * elements with text wrapping, and then remove empty space between widgets. * By default, if QLabel contains more than one line of text, it often occupies * more space than required, and calling setMinimumHeight() doesn't affect this. */ void DirResourceImportTypeWidget::setTextSizes() { const int spacing = style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing); mUi->spacer1->changeSize(10, 2*spacing, QSizePolicy::Fixed, QSizePolicy::Fixed); mUi->spacer2->changeSize(10, 2*spacing, QSizePolicy::Fixed, QSizePolicy::Fixed); mUi->spacer3->changeSize(10, 2*spacing, QSizePolicy::Fixed, QSizePolicy::Fixed); setFixedHeight(sizeHint().height()); } bool DirResourceImportTypeWidget::eventFilter(QObject* o, QEvent* e) { if (o == mUi->pathRequester && e->type() == QEvent::FocusOut) validate(); return QWidget::eventFilter(o, e); } /****************************************************************************** * Called when an import destination type radio button has been selected. * Enable or disable the other controls. */ void DirResourceImportTypeWidget::importTypeSelected() { const bool importMerge = mUi->mergeRadio->isChecked(); const bool importNew = mUi->newRadio->isChecked(); mUi->mergeResource->setEnabled(importMerge); mUi->pathLabel->setEnabled(importNew); mUi->pathRequester->setEnabled(importNew); mUi->statusLabel->setEnabled(importNew); mUi->nameLabel->setEnabled(importNew); mUi->nameText->setEnabled(importNew); if (importNew) validate(); else if (importMerge || mUi->noRadio->isChecked()) Q_EMIT status(true); } /****************************************************************************** * Validate the current user input. If invalid, disable the OK button. * Reply = false if invalid, or if waiting for remote validity to be checked. */ void DirResourceImportTypeWidget::validate() { if (!mUi->newRadio->isChecked()) return; // Validate URL first, in order to display any error message. const QUrl currentUrl = mUi->pathRequester->url(); if (mUi->pathRequester->text().trimmed().isEmpty() || currentUrl.isEmpty()) { setStatus(false); return; } if (mUrlValidationFunc) { const QString error = (*mUrlValidationFunc)(currentUrl); if (!error.isEmpty()) { setStatus(false, error); return; } } if (!currentUrl.isLocalFile()) { // It's a remote file. // Check whether the file can be read or written. if (mStatJob) mStatJob->kill(); mCheckingDir = false; mStatJob = KIO::statDetails(currentUrl, KIO::StatJob::SourceSide, KIO::StatDetail::StatNoDetails, KIO::HideProgressInfo); connect(mStatJob, &KIO::StatJob::result, this, &DirResourceImportTypeWidget::slotStatJobResult); // Disable the OK button until the file's status is determined. setStatus(false, i18nc("@info:status", "Checking file information..."), false); return; } // It's a local file. Check that it doesn't already exist, and that it can be created. QFileInfo file(currentUrl.toLocalFile()); if (file.exists()) { setStatus(false, i18nc("@info:status", "Error! File already exists.")); return; } QFileInfo dir(file.path()); if (!dir.exists()) { setStatus(false, i18nc("@info:status", "Error! Cannot create file (directory does not exist).")); return; } if (!dir.isWritable()) { setStatus(false, i18nc("@info:status", "Error! Cannot create file (directory is not writable).")); return; } if (mUi->nameText->text().trimmed().isEmpty()) { setStatus(false); return; } setStatus(true); } /****************************************************************************** * Called when the status of the remote URL has been determined. * Ensures that the URL doesn't exist, but can be created. */ void DirResourceImportTypeWidget::slotStatJobResult(KJob* job) { KIO::StatJob* statJob = static_cast(job); mStatJob = nullptr; if (!mCheckingDir) { // Results from checking the remote file. if (job->error() == KIO::ERR_DOES_NOT_EXIST) { // The file doesn't exist (as expected), so check that the file's // directory is writable. mCheckingDir = true; mStatJob = KIO::statDetails(KIO::upUrl(mUi->pathRequester->url()), KIO::StatJob::SourceSide, KIO::StatDetail::StatDefaultDetails, KIO::HideProgressInfo); connect(mStatJob, &KIO::StatJob::result, this, &DirResourceImportTypeWidget::slotStatJobResult); return; } setStatus(false, i18nc("@info:status", "Error! File already exists.")); } else { // Results from checking the remote file's directory. mCheckingDir = false; if (job->error()) { if (job->error() == KIO::ERR_DOES_NOT_EXIST) setStatus(false, i18nc("@info:status", "Error! Cannot create file (directory does not exist).")); else setStatus(false, i18nc("@info:status", "Error! Cannot create file (directory is not writable).")); } else { KFileItem fi(statJob->statResult(), KIO::upUrl(mUi->pathRequester->url())); if (!fi.isDir()) setStatus(false, i18nc("@info", "Error! Cannot create file (directory does not exist).")); else if (!fi.isWritable()) setStatus(false, i18nc("@info", "Error! Cannot create file (directory is not writable).")); else setStatus(true); } } } /****************************************************************************** * Set or clear the URL status message, and notify the dialog of the new status. */ void DirResourceImportTypeWidget::setStatus(bool ok, const QString& errorMessage, bool errorColour) { if (ok) mUi->statusLabel->setText(QString()); else { QPalette pal = mUi->pathLabel->palette(); if (errorColour && !errorMessage.isEmpty()) pal.setColor(QPalette::WindowText, KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText).color()); mUi->statusLabel->setPalette(pal); mUi->statusLabel->setText(errorMessage); } Q_EMIT status(ok); } // vim: et sw=4: diff --git a/src/resources/singlefileresourceconfigdialog.cpp b/src/resources/singlefileresourceconfigdialog.cpp index 15af0d8a..66801166 100644 --- a/src/resources/singlefileresourceconfigdialog.cpp +++ b/src/resources/singlefileresourceconfigdialog.cpp @@ -1,319 +1,319 @@ /* * singlefileresourceconfigdialog.cpp - configuration dialog for single file resources. * Program: kalarm * Copyright © 2020 David Jarvie * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "singlefileresourceconfigdialog.h" #include "ui_singlefileresourceconfigdialog.h" #include #include #include #include #include using namespace KAlarmCal; namespace { void setTextEditHeight(KTextEdit*, QGroupBox*); } SingleFileResourceConfigDialog::SingleFileResourceConfigDialog(bool create, QWidget* parent) : QDialog(parent) , mCreating(create) { mUi = new Ui_SingleFileResourceConfigWidget; mUi->setupUi(this); setWindowTitle(i18nc("@title:window", "Configure Calendar")); if (mCreating) { mUi->pathText->setVisible(false); mUi->alarmTypeLabel->setVisible(false); mUi->pathRequester->setMode(KFile::File); - mUi->pathRequester->setFilter(QStringLiteral("*.ics|%1").arg(i18nc("@item:inlistbox File type selection filter", "Calendar Files"))); + mUi->pathRequester->setFilter(QStringLiteral("*.ics|%1").arg(i18nc("@item:inlistbox File type selection filter", "Calendar files"))); mUi->pathRequester->setFocus(); mUi->statusLabel->setText(QString()); connect(mUi->pathRequester, &KUrlRequester::textChanged, this, &SingleFileResourceConfigDialog::validate); connect(mUi->alarmTypeGroup, QOverload::of(&QButtonGroup::buttonToggled), this, &SingleFileResourceConfigDialog::validate); } else { mUi->pathRequester->setVisible(false); mUi->statusLabel->setVisible(false); mUi->pathDescription->setVisible(false); mUi->activeRadio->setVisible(false); mUi->archivedRadio->setVisible(false); mUi->templateRadio->setVisible(false); mUi->alarmTypeDescription->setVisible(false); mUi->displayNameText->setFocus(); } connect(mUi->displayNameText, &QLineEdit::textChanged, this, &SingleFileResourceConfigDialog::validate); connect(mUi->buttonBox, &QDialogButtonBox::rejected, this, &SingleFileResourceConfigDialog::close); connect(mUi->buttonBox, &QDialogButtonBox::accepted, this, &SingleFileResourceConfigDialog::accept); QTimer::singleShot(0, this, &SingleFileResourceConfigDialog::validate); } SingleFileResourceConfigDialog::~SingleFileResourceConfigDialog() { delete mUi; } void SingleFileResourceConfigDialog::setUrl(const QUrl& url, bool readOnly) { if (mCreating) { mUi->pathRequester->setUrl(url); if (readOnly) { mUi->pathRequester->lineEdit()->setEnabled(false); mUi->pathRequester->button()->setVisible(false); mUi->statusLabel->setVisible(false); mUi->activeRadio->setEnabled(false); mUi->archivedRadio->setEnabled(false); mUi->templateRadio->setEnabled(false); enableOkButton(); } } else { mUi->pathText->setText(url.toDisplayString(QUrl::PrettyDecoded | QUrl::PreferLocalFile)); } } QUrl SingleFileResourceConfigDialog::url() const { return mCreating ? mUi->pathRequester->url() : QUrl(); } QString SingleFileResourceConfigDialog::displayName() const { return mUi->displayNameText->text(); } void SingleFileResourceConfigDialog::setDisplayName(const QString& name) { mUi->displayNameText->setText(name); } bool SingleFileResourceConfigDialog::readOnly() const { return mUi->readOnlyCheckbox->isChecked(); } void SingleFileResourceConfigDialog::setReadOnly(bool readonly) { mUi->readOnlyCheckbox->setChecked(readonly); } CalEvent::Type SingleFileResourceConfigDialog::alarmType() const { if (mCreating) { if (mUi->activeRadio->isChecked()) return CalEvent::ACTIVE; if (mUi->archivedRadio->isChecked()) return CalEvent::ARCHIVED; if (mUi->templateRadio->isChecked()) return CalEvent::TEMPLATE; } return CalEvent::EMPTY; } void SingleFileResourceConfigDialog::setAlarmType(CalEvent::Type type) { switch (type) { case CalEvent::ACTIVE: if (mCreating) mUi->activeRadio->setChecked(true); else mUi->activeAlarmsText->setVisible(true); break; case CalEvent::ARCHIVED: if (mCreating) mUi->archivedRadio->setChecked(true); else mUi->archivedAlarmsText->setVisible(true); break; case CalEvent::TEMPLATE: if (mCreating) mUi->templateRadio->setChecked(true); else mUi->templateAlarmsText->setVisible(true); break; default: break; } } void SingleFileResourceConfigDialog::setUrlValidation(QString (*func)(const QUrl&)) { if (mCreating) mUrlValidationFunc = func; } /****************************************************************************** * Validate the current user input. If invalid, disable the OK button. */ void SingleFileResourceConfigDialog::validate() { // Validate URL first, in order to display any error message. const QUrl currentUrl = mUi->pathRequester->url(); if (mUi->pathRequester->text().trimmed().isEmpty() || currentUrl.isEmpty()) { disableOkButton(QString()); return; } if (mUrlValidationFunc) { const QString error = (*mUrlValidationFunc)(currentUrl); if (!error.isEmpty()) { disableOkButton(error, true); return; } } if (mUi->displayNameText->text().trimmed().isEmpty() || (mCreating && !mUi->alarmTypeGroup->checkedButton())) { disableOkButton(QString()); return; } if (!mCreating) { enableOkButton(); return; } if (currentUrl.isLocalFile()) enableOkButton(); else { // It's a remote file. // Check whether the file can be read or written. if (mStatJob) mStatJob->kill(); mCheckingDir = false; initiateUrlStatusCheck(currentUrl); // Disable the OK button until the file's status is determined. disableOkButton(i18nc("@info:status", "Checking file information...")); } } /****************************************************************************** * Called when the status of the remote URL has been determined. * Checks whether the URL is accessible. */ void SingleFileResourceConfigDialog::slotStatJobResult(KJob* job) { if (job->error()) { if (job->error() == KIO::ERR_DOES_NOT_EXIST && !mCheckingDir) { // The file doesn't exist, so check if the file's directory is writable. mCheckingDir = true; initiateUrlStatusCheck(KIO::upUrl(mUi->pathRequester->url())); return; } // Can't read or write the URL. disableOkButton(QString()); } else enableOkButton(); mCheckingDir = false; mStatJob = nullptr; } /****************************************************************************** * Creates a job to check the status of a remote URL. */ void SingleFileResourceConfigDialog::initiateUrlStatusCheck(const QUrl& url) { mStatJob = KIO::statDetails(url, KIO::StatJob::SourceSide, KIO::StatDetail::StatDefaultDetails, KIO::HideProgressInfo); connect(mStatJob, &KIO::StatJob::result, this, &SingleFileResourceConfigDialog::slotStatJobResult); } /****************************************************************************** * Enable the OK button, and clear the URL status message. */ void SingleFileResourceConfigDialog::enableOkButton() { mUi->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true); mUi->statusLabel->setText(QString()); } /****************************************************************************** * Disable the OK button, and set the URL status message. */ void SingleFileResourceConfigDialog::disableOkButton(const QString& statusMessage, bool errorColour) { mUi->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false); QPalette pal = mUi->pathLabel->palette(); if (errorColour) pal.setColor(QPalette::WindowText, KColorScheme(QPalette::Active).foreground(KColorScheme::NegativeText).color()); mUi->statusLabel->setPalette(pal); mUi->statusLabel->setText(statusMessage); } /****************************************************************************** * When the dialog is displayed, set appropriate heights for KTextEdit elements, * and then remove empty space between widgets. * By default, KTextEdit has a minimum height of 4 text lines, and calling * setMinimumHeight() doesn't affect this. */ void SingleFileResourceConfigDialog::showEvent(QShowEvent* se) { setTextEditHeight(mUi->nameDescription, mUi->nameGroupBox); setTextEditHeight(mUi->readOnlyDescription, mUi->readOnlyGroupBox); if (mCreating) { setTextEditHeight(mUi->pathDescription, mUi->pathGroupBox); setTextEditHeight(mUi->alarmTypeDescription, mUi->alarmTypeGroupBox); } else mUi->pathDescription->setFixedHeight(1); setFixedHeight(sizeHint().height()); QDialog::showEvent(se); } namespace { void setTextEditHeight(KTextEdit* textEdit, QGroupBox* groupBox) { const QSize size = textEdit->document()->size().toSize(); const int margin = textEdit->height() - textEdit->viewport()->height(); textEdit->setFixedHeight(size.height() + margin); groupBox->setFixedHeight(groupBox->sizeHint().height()); } } // vim: et sw=4: