mirror of
https://bitbucket.org/smil3y/kde-playground.git
synced 2025-02-24 10:52:52 +00:00
931 lines
44 KiB
C++
931 lines
44 KiB
C++
/*
|
|
Copyright (c) 2012-2013 Montel Laurent <montel@kde.org>
|
|
|
|
This program is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License, version 2, as
|
|
published by the Free Software Foundation.
|
|
|
|
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 "thunderbirdsettings.h"
|
|
#include <mailtransport/transportmanager.h>
|
|
#include "mailcommon/util/mailutil.h"
|
|
#include "importwizardutil.h"
|
|
|
|
#include <kpimidentities/identity.h>
|
|
#include <kpimidentities/signature.h>
|
|
#include <KStandardDirs>
|
|
|
|
#include <KABC/VCardConverter>
|
|
#include <QTextStream>
|
|
#include <QStringList>
|
|
#include <QFile>
|
|
#include <KDebug>
|
|
|
|
ThunderbirdSettings::ThunderbirdSettings( const QString& filename, ImportWizard *parent )
|
|
:AbstractSettings( parent )
|
|
{
|
|
QFile file(filename);
|
|
if ( !file.open( QIODevice::ReadOnly ) ) {
|
|
kDebug()<<" We can't open file"<<filename;
|
|
return;
|
|
}
|
|
QTextStream stream(&file);
|
|
while ( !stream.atEnd() ) {
|
|
const QString line = stream.readLine();
|
|
if (line.startsWith(QLatin1String("user_pref"))) {
|
|
if (line.contains(QLatin1String("mail.smtpserver")) ||
|
|
line.contains(QLatin1String("mail.server.")) ||
|
|
line.contains(QLatin1String("mail.identity.")) ||
|
|
line.contains(QLatin1String("mail.account.")) ||
|
|
line.contains(QLatin1String("mail.accountmanager.")) ||
|
|
line.contains(QLatin1String("mailnews."))||
|
|
line.contains(QLatin1String("mail.compose."))||
|
|
line.contains(QLatin1String("mail.spellcheck")) ||
|
|
line.contains(QLatin1String("mail.SpellCheckBeforeSend")) ||
|
|
line.contains(QLatin1String("spellchecker.dictionary")) ||
|
|
line.contains(QLatin1String("ldap_")) ||
|
|
line.contains(QLatin1String("mail.biff.")) ||
|
|
line.contains(QLatin1String("mailnews.tags.")) ||
|
|
line.contains(QLatin1String("extensions.AutoResizeImage.")) ||
|
|
line.contains(QLatin1String("mail.phishing.")) ||
|
|
line.contains(QLatin1String("mail.display_glyph"))) {
|
|
insertIntoMap( line );
|
|
}
|
|
} else {
|
|
kDebug()<<" unstored line :"<<line;
|
|
}
|
|
}
|
|
const QString mailAccountPreference = mHashConfig.value( QLatin1String( "mail.accountmanager.accounts" ) ).toString();
|
|
if ( mailAccountPreference.isEmpty() )
|
|
return;
|
|
mAccountList = mailAccountPreference.split( QLatin1Char( ',' ) );
|
|
readTransport();
|
|
readAccount();
|
|
readGlobalSettings();
|
|
readLdapSettings();
|
|
readTagSettings();
|
|
readExtensionsSettings();
|
|
}
|
|
|
|
ThunderbirdSettings::~ThunderbirdSettings()
|
|
{
|
|
}
|
|
|
|
void ThunderbirdSettings::readExtensionsSettings()
|
|
{
|
|
//AutoResizeImage
|
|
const QString filterPatternEnabledStr = QLatin1String("extensions.AutoResizeImage.filterPatterns");
|
|
if (mHashConfig.contains(filterPatternEnabledStr)) {
|
|
const int filterPatternType = mHashConfig.value(filterPatternEnabledStr).toInt();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("filter-source-type"), filterPatternType);
|
|
}
|
|
const QString filterPatternListStr = QLatin1String("extensions.AutoResizeImage.filteringPatternsList");
|
|
if (mHashConfig.contains(filterPatternListStr)) {
|
|
const QString filterPatternList = mHashConfig.value(filterPatternListStr).toString();
|
|
//TODO decode it.
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("filter-source-pattern"), filterPatternList );
|
|
}
|
|
|
|
const QString enlargeImagesStr = QLatin1String("extensions.AutoResizeImage.enlargeImages");
|
|
if (mHashConfig.contains(enlargeImagesStr)) {
|
|
const bool enlargeImages = mHashConfig.value(enlargeImagesStr).toBool();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("enlarge-image-to-minimum"), enlargeImages );
|
|
}
|
|
|
|
const QString maxResolutionXStr = QLatin1String("extensions.AutoResizeImage.maxResolutionX");
|
|
if (mHashConfig.contains(maxResolutionXStr)) {
|
|
const int val = mHashConfig.value(maxResolutionXStr).toInt();
|
|
int adaptedValue = adaptAutoResizeResolution(val,QLatin1String("extensions.AutoResizeImage.maxResolutionXList"));
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("maximum-width"), adaptedValue );
|
|
}
|
|
const QString maxResolutionYStr = QLatin1String("extensions.AutoResizeImage.maxResolutionY");
|
|
if (mHashConfig.contains(maxResolutionYStr)) {
|
|
const int val = mHashConfig.value(maxResolutionYStr).toInt();
|
|
int adaptedValue = adaptAutoResizeResolution(val,QLatin1String("extensions.AutoResizeImage.maxResolutionYList"));
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("maximum-height"), adaptedValue );
|
|
}
|
|
const QString minResolutionXStr = QLatin1String("extensions.AutoResizeImage.minResolutionX");
|
|
if (mHashConfig.contains(minResolutionXStr)) {
|
|
const int val = mHashConfig.value(minResolutionXStr).toInt();
|
|
int adaptedValue = adaptAutoResizeResolution(val,QLatin1String("extensions.AutoResizeImage.minResolutionXList"));
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("minimum-width"), adaptedValue );
|
|
}
|
|
const QString minResolutionYStr = QLatin1String("extensions.AutoResizeImage.minResolutionY");
|
|
if (mHashConfig.contains(minResolutionYStr)) {
|
|
const int val = mHashConfig.value(minResolutionYStr).toInt();
|
|
int adaptedValue = adaptAutoResizeResolution(val,QLatin1String("extensions.AutoResizeImage.minResolutionYList"));
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("minimum-height"), adaptedValue );
|
|
}
|
|
|
|
//Default is true.
|
|
const QString reduceImageStr(QLatin1String("extensions.AutoResizeImage.reduceImages"));
|
|
if (mHashConfig.contains(reduceImageStr)) {
|
|
const bool reduce = mHashConfig.value(reduceImageStr).toBool();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("reduce-image-to-maximum"), reduce );
|
|
} else {
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("reduce-image-to-maximum"), false );
|
|
}
|
|
|
|
const QString filterMinimumStr(QLatin1String("extensions.AutoResizeImage.filterMinimumSize"));
|
|
if (mHashConfig.contains(filterMinimumStr)) {
|
|
const bool filterMinimum = mHashConfig.value(filterMinimumStr).toBool();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("skip-image-lower-size-enabled"), filterMinimum );
|
|
}
|
|
const QString skipMinimumSizeStr(QLatin1String("extensions.AutoResizeImage.minimumSize"));
|
|
if (mHashConfig.contains(skipMinimumSizeStr)) {
|
|
const int skipMinimumSize = mHashConfig.value(skipMinimumSizeStr).toInt();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("skip-image-lower-size"), skipMinimumSize );
|
|
}
|
|
const QString confirmBeforeResizingStr(QLatin1String("extensions.AutoResizeImage.confirmResizing"));
|
|
if (mHashConfig.contains(confirmBeforeResizingStr)) {
|
|
const bool confirmBeforeResizing = mHashConfig.value(confirmBeforeResizingStr).toBool();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("ask-before-resizing"), confirmBeforeResizing );
|
|
}
|
|
//extensions.AutoResizeImage.convertImages : not implemented in kmail
|
|
|
|
const QString conversionFormatStr(QLatin1String("extensions.AutoResizeImage.conversionFormat"));
|
|
if (mHashConfig.contains(conversionFormatStr)) {
|
|
QString conversionFormat = mHashConfig.value(conversionFormatStr).toString();
|
|
if (conversionFormat == QLatin1String("png")) {
|
|
conversionFormat = QLatin1String("PNG");
|
|
} else {
|
|
conversionFormat = QLatin1String("JPG");
|
|
}
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("write-format"), conversionFormat );
|
|
}
|
|
|
|
const QString filterRecipientsStr(QLatin1String("extensions.AutoResizeImage.filterRecipients"));
|
|
if (mHashConfig.contains(filterRecipientsStr)) {
|
|
const int filterRecipients = mHashConfig.value(filterRecipientsStr).toInt();
|
|
switch(filterRecipients) {
|
|
case 0:
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("FilterRecipientType"), QLatin1String("NoFilter") );
|
|
break;
|
|
case 1:
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("FilterRecipientType"), QLatin1String("ResizeEachEmailsContainsPattern") );
|
|
break;
|
|
case 2:
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("FilterRecipientType"), QLatin1String("ResizeOneEmailContainsPattern") );
|
|
break;
|
|
case 3:
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("FilterRecipientType"), QLatin1String("DontResizeEachEmailsContainsPattern") );
|
|
break;
|
|
case 4:
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("FilterRecipientType"), QLatin1String("DontResizeOneEmailContainsPattern") );
|
|
break;
|
|
default:
|
|
qDebug()<<" unknow FilterRecipientType: "<<filterRecipients;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const QString filteringRecipientsPatternsWhiteListStr(QLatin1String("extensions.AutoResizeImage.filteringRecipientsPatternsWhiteList"));
|
|
if (mHashConfig.contains(filteringRecipientsPatternsWhiteListStr)) {
|
|
const QString filteringRecipientsPatternsWhiteList = mHashConfig.value(filteringRecipientsPatternsWhiteListStr).toString();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("resize-emails-pattern"), filteringRecipientsPatternsWhiteList );
|
|
}
|
|
|
|
const QString filteringRecipientsPatternsBlackListStr(QLatin1String("extensions.AutoResizeImage.filteringRecipientsPatternsBlackList"));
|
|
if (mHashConfig.contains(filteringRecipientsPatternsBlackListStr)) {
|
|
const QString filteringRecipientsPatternsBlackList = mHashConfig.value(filteringRecipientsPatternsBlackListStr).toString();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("do-not-resize-emails-pattern"), filteringRecipientsPatternsBlackList );
|
|
}
|
|
|
|
const QString filteringRenamingPatternStr(QLatin1String("extensions.AutoResizeImage.renamingPattern"));
|
|
if (mHashConfig.contains(filteringRenamingPatternStr)) {
|
|
QString filteringRenamingPattern = mHashConfig.value(filteringRenamingPatternStr).toString();
|
|
filteringRenamingPattern.replace(QLatin1String("%3Fn"), QLatin1String("%n"));
|
|
filteringRenamingPattern.replace(QLatin1String("%3Ft"), QLatin1String("%t"));
|
|
filteringRenamingPattern.replace(QLatin1String("%3Fd"), QLatin1String("%d"));
|
|
filteringRenamingPattern.replace(QLatin1String("%3Fe"), QLatin1String("%e"));
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("rename-resized-images-pattern"), filteringRenamingPattern);
|
|
}
|
|
|
|
const QString filteringRenamingImageStr(QLatin1String("extensions.AutoResizeImage.renameResizedImages"));
|
|
if (mHashConfig.contains(filteringRenamingImageStr)) {
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("rename-resized-images"), true);
|
|
}
|
|
|
|
const QString filteringImageFormatsStr(QLatin1String("extensions.AutoResizeImage.imageFormats"));
|
|
if (mHashConfig.contains(filteringImageFormatsStr)) {
|
|
const QString filteringImageFormats = mHashConfig.value(filteringImageFormatsStr).toString();
|
|
//convert it.
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("resize-image-with-formats-type"), filteringImageFormats);
|
|
}
|
|
|
|
const QString filteringImageFormatsEnabledStr(QLatin1String("extensions.AutoResizeImage.filterFormats"));
|
|
if (mHashConfig.contains(filteringImageFormatsEnabledStr)) {
|
|
const bool filteringImageFormatsEnabled = mHashConfig.value(filteringImageFormatsEnabledStr).toBool();
|
|
addKmailConfig(QLatin1String("AutoResizeImage"), QLatin1String("resize-image-with-formats"), filteringImageFormatsEnabled);
|
|
}
|
|
}
|
|
|
|
int ThunderbirdSettings::adaptAutoResizeResolution(int index, const QString& configStrList)
|
|
{
|
|
switch(index) {
|
|
case 0:
|
|
return 240;
|
|
case 1:
|
|
return 320;
|
|
case 2:
|
|
return 512;
|
|
case 3:
|
|
return 640;
|
|
case 4:
|
|
return 800;
|
|
case 5:
|
|
return 1024;
|
|
case 6:
|
|
return 1280;
|
|
case 7:
|
|
return 2048;
|
|
case 8:
|
|
return 1024;
|
|
case 9: //custom case
|
|
{
|
|
if (mHashConfig.contains(configStrList)) {
|
|
const QString res = mHashConfig.value(configStrList).toString();
|
|
const QStringList lst = res.split(QLatin1Char(';'));
|
|
int val = lst.last().toInt();
|
|
return val;
|
|
}
|
|
}
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void ThunderbirdSettings::readTagSettings()
|
|
{
|
|
ImportWizardUtil::addAkonadiTag(mHashTag.values());
|
|
}
|
|
|
|
void ThunderbirdSettings::readLdapSettings()
|
|
{
|
|
//qDebug()<<" mLdapAccountList:"<<mLdapAccountList;
|
|
Q_FOREACH (const QString& ldapAccountName, mLdapAccountList) {
|
|
ldapStruct ldap;
|
|
const QString ldapDescription = QString::fromLatin1("%1.description").arg(ldapAccountName);
|
|
if (mHashConfig.contains(ldapDescription)) {
|
|
ldap.description = mHashConfig.value(ldapDescription).toString();
|
|
}
|
|
const QString ldapAuthDn = QString::fromLatin1("%1.auth.dn").arg(ldapAccountName);
|
|
if (mHashConfig.contains(ldapAuthDn)) {
|
|
ldap.dn = mHashConfig.value(ldapAuthDn).toString();
|
|
}
|
|
const QString ldapAuthSaslMech = QString::fromLatin1("%1.auth.saslmech").arg(ldapAccountName);
|
|
if (mHashConfig.contains(ldapAuthSaslMech)) {
|
|
ldap.saslMech = mHashConfig.value(ldapAuthSaslMech).toString();
|
|
}
|
|
const QString ldapFilename = QString::fromLatin1("%1.filename").arg(ldapAccountName);
|
|
if (mHashConfig.contains(ldapFilename)) {
|
|
ldap.fileName = mHashConfig.value(ldapFilename).toString();
|
|
}
|
|
const QString ldapMaxHits = QString::fromLatin1("%1.maxHits").arg(ldapAccountName);
|
|
if (mHashConfig.contains(ldapMaxHits)) {
|
|
ldap.fileName = mHashConfig.value(ldapMaxHits).toInt();
|
|
}
|
|
const QString ldapUri = QString::fromLatin1("%1.uri").arg(ldapAccountName);
|
|
if (mHashConfig.contains(ldapUri)) {
|
|
ldap.ldapUrl = KUrl(mHashConfig.value(ldapUri).toString());
|
|
ldap.port = ldap.ldapUrl.port();
|
|
|
|
if (ldap.ldapUrl.scheme() == QLatin1String("ldaps")) {
|
|
ldap.useSSL = true;
|
|
} else if (ldap.ldapUrl.scheme() == QLatin1String("ldap")) {
|
|
ldap.useSSL = false;
|
|
} else {
|
|
qDebug()<<" Security not implemented :"<<ldap.ldapUrl.scheme();
|
|
}
|
|
}
|
|
ImportWizardUtil::mergeLdap(ldap);
|
|
}
|
|
}
|
|
|
|
void ThunderbirdSettings::readGlobalSettings()
|
|
{
|
|
const QString markMessageReadStr = QLatin1String("mailnews.mark_message_read.delay");
|
|
if (mHashConfig.contains(markMessageReadStr)) {
|
|
const bool markMessageRead = mHashConfig.value(markMessageReadStr).toBool();
|
|
addKmailConfig(QLatin1String("Behaviour"), QLatin1String("DelayedMarkAsRead"), markMessageRead);
|
|
} else {
|
|
//Default value
|
|
addKmailConfig(QLatin1String("Behaviour"), QLatin1String("DelayedMarkAsRead"), true);
|
|
}
|
|
const QString markMessageReadIntervalStr = QLatin1String("mailnews.mark_message_read.delay.interval");
|
|
if (mHashConfig.contains(markMessageReadIntervalStr)) {
|
|
bool found = false;
|
|
const int markMessageReadInterval = mHashConfig.value(markMessageReadIntervalStr).toInt(&found);
|
|
if (found) {
|
|
addKmailConfig(QLatin1String("Behaviour"), QLatin1String("DelayedMarkTime"), markMessageReadInterval);
|
|
}
|
|
} else {
|
|
//Default 5 seconds
|
|
addKmailConfig(QLatin1String("Behaviour"), QLatin1String("DelayedMarkTime"), 5);
|
|
}
|
|
|
|
const QString mailComposeAttachmentReminderStr = QLatin1String("mail.compose.attachment_reminder");
|
|
if (mHashConfig.contains(mailComposeAttachmentReminderStr)) {
|
|
const bool mailComposeAttachmentReminder = mHashConfig.value(mailComposeAttachmentReminderStr).toBool();
|
|
addKmailConfig(QLatin1String("Composer"), QLatin1String("showForgottenAttachmentWarning"), mailComposeAttachmentReminder);
|
|
} else {
|
|
addKmailConfig(QLatin1String("Composer"), QLatin1String("showForgottenAttachmentWarning"), true);
|
|
}
|
|
|
|
const QString mailComposeAttachmentReminderKeywordsStr = QLatin1String("mail.compose.attachment_reminder_keywords");
|
|
if (mHashConfig.contains(mailComposeAttachmentReminderKeywordsStr)) {
|
|
const QString mailComposeAttachmentReminderKeywords = mHashConfig.value(mailComposeAttachmentReminderKeywordsStr).toString();
|
|
addKmailConfig(QLatin1String("Composer"), QLatin1String("attachment-keywords"), mailComposeAttachmentReminderKeywords);
|
|
} //not default value keep kmail use one default value
|
|
|
|
const QString mailComposeAutosaveStr = QLatin1String("mail.compose.autosave");
|
|
if (mHashConfig.contains(mailComposeAutosaveStr)) {
|
|
const bool mailComposeAutosave = mHashConfig.value(mailComposeAutosaveStr).toBool();
|
|
if (mailComposeAutosave) {
|
|
const QString mailComposeAutosaveintervalStr = QLatin1String("mail.compose.autosaveinterval");
|
|
if (mHashConfig.contains(mailComposeAutosaveintervalStr)) {
|
|
bool found = false;
|
|
const int mailComposeAutosaveinterval = mHashConfig.value(mailComposeAutosaveintervalStr).toInt(&found);
|
|
if (found) {
|
|
addKmailConfig(QLatin1String("Composer"), QLatin1String("autosave"), mailComposeAutosaveinterval);
|
|
} else {
|
|
addKmailConfig(QLatin1String("Composer"), QLatin1String("autosave"), 5);
|
|
}
|
|
} else {
|
|
//Default value
|
|
addKmailConfig(QLatin1String("Composer"), QLatin1String("autosave"), 5);
|
|
}
|
|
} else {
|
|
//Don't autosave
|
|
addKmailConfig(QLatin1String("Composer"), QLatin1String("autosave"), 0);
|
|
}
|
|
}
|
|
|
|
const QString mailSpellCheckInlineStr = QLatin1String("mail.spellcheck.inline");
|
|
if (mHashConfig.contains(mailSpellCheckInlineStr)) {
|
|
const bool mailSpellCheckInline = mHashConfig.value(mailSpellCheckInlineStr).toBool();
|
|
addKmailConfig(QLatin1String("Spelling"),QLatin1String("backgroundCheckerEnabled"),mailSpellCheckInline);
|
|
} else {
|
|
addKmailConfig(QLatin1String("Spelling"),QLatin1String("backgroundCheckerEnabled"),false);
|
|
}
|
|
const QString mailPlaySoundStr = QLatin1String("mail.biff.play_sound");
|
|
if (mHashConfig.contains(mailPlaySoundStr)) {
|
|
const bool mailPlaySound = mHashConfig.value(mailPlaySoundStr).toBool();
|
|
addKmailConfig(QLatin1String("General"),QLatin1String("beep-on-mail"), mailPlaySound);
|
|
} else {
|
|
//Default value in thunderbird
|
|
addKmailConfig(QLatin1String("General"),QLatin1String("beep-on-mail"), true);
|
|
}
|
|
|
|
const QString mailAlertShowSubjectStr = QLatin1String("mail.biff.alert.show_subject");
|
|
if (mHashConfig.contains(mailAlertShowSubjectStr)) {
|
|
const bool mailAlertShowSubject = mHashConfig.value(mailAlertShowSubjectStr).toBool();
|
|
addNewMailNotifier(QLatin1String("General"),QLatin1String("showSubject"), mailAlertShowSubject);
|
|
} else {
|
|
//Default value in thunderbird
|
|
addNewMailNotifier(QLatin1String("General"),QLatin1String("showSubject"), true);
|
|
}
|
|
|
|
const QString mailAlertShowPreviewStr = QLatin1String("mail.biff.alert.show_preview");
|
|
//TODO add show preview
|
|
if (mHashConfig.contains(mailAlertShowPreviewStr)) {
|
|
const bool mailAlertShowPreview = mHashConfig.value(mailAlertShowPreviewStr).toBool();
|
|
//addNewMailNotifier(QLatin1String("General"),QLatin1String("showSubject"), mailAlertShowPreview);
|
|
} else {
|
|
//Default value in thunderbird
|
|
//addNewMailNotifier(QLatin1String("General"),QLatin1String("showSubject"), true);
|
|
}
|
|
|
|
const QString mailAlertShowSenderStr = QLatin1String("mail.biff.alert.show_sender");
|
|
if (mHashConfig.contains(mailAlertShowSenderStr)) {
|
|
const bool mailAlertShowSender = mHashConfig.value(mailAlertShowSenderStr).toBool();
|
|
addNewMailNotifier(QLatin1String("General"), QLatin1String("showFrom"), mailAlertShowSender);
|
|
} else {
|
|
//Default value in thunderbird
|
|
addNewMailNotifier(QLatin1String("General"), QLatin1String("showFrom"), true);
|
|
}
|
|
|
|
|
|
|
|
const QString mailSpellCheckBeforeSendStr = QLatin1String("mail.SpellCheckBeforeSend");
|
|
if (mHashConfig.contains(mailSpellCheckBeforeSendStr)) {
|
|
const bool mailSpellCheckBeforeSend = mHashConfig.value(mailSpellCheckBeforeSendStr).toBool();
|
|
addKmailConfig(QLatin1String("Composer"),QLatin1String("check-spelling-before-send"), mailSpellCheckBeforeSend);
|
|
} else {
|
|
addKmailConfig(QLatin1String("Composer"),QLatin1String("check-spelling-before-send"), false);
|
|
}
|
|
|
|
const QString mailSpellCheckLanguageStr = QLatin1String("spellchecker.dictionary");
|
|
if (mHashConfig.contains(mailSpellCheckLanguageStr)) {
|
|
const QString mailSpellCheckLanguage = mHashConfig.value(mailSpellCheckLanguageStr).toString();
|
|
addKmailConfig(QLatin1String("Spelling"), QLatin1String("defaultLanguage"),mailSpellCheckLanguage);
|
|
//TODO create map to convert thunderbird name to aspell name
|
|
}
|
|
|
|
const QString mailPhishingDetectionStr = QLatin1String("mail.phishing.detection.enabled");
|
|
if (mHashConfig.contains(mailPhishingDetectionStr)) {
|
|
const bool mailPhishingDetectionEnabled = mHashConfig.value(mailPhishingDetectionStr).toBool();
|
|
addKmailConfig(QLatin1String("Reader"), QLatin1String("ScamDetectionEnabled"), mailPhishingDetectionEnabled);
|
|
} else { //Default
|
|
addKmailConfig(QLatin1String("Reader"), QLatin1String("ScamDetectionEnabled"), true);
|
|
}
|
|
|
|
const QString mailDisplayGlyphStr = QLatin1String("mail.display_glyph");
|
|
if (mHashConfig.contains(mailDisplayGlyphStr)) {
|
|
const bool mailDisplayGlyphEnabled = mHashConfig.value(mailDisplayGlyphStr).toBool();
|
|
addKmailConfig(QLatin1String("Reader"), QLatin1String("ShowEmoticons"), mailDisplayGlyphEnabled);
|
|
} else { //Default
|
|
addKmailConfig(QLatin1String("Reader"), QLatin1String("ShowEmoticons"), true);
|
|
}
|
|
|
|
}
|
|
|
|
void ThunderbirdSettings::addAuth(QMap<QString, QVariant>& settings, const QString & argument, const QString &accountName )
|
|
{
|
|
bool found = false;
|
|
if ( mHashConfig.contains( accountName + QLatin1String( ".authMethod" ) ) ) {
|
|
const int authMethod = mHashConfig.value( accountName + QLatin1String( ".authMethod" ) ).toInt(&found);
|
|
if ( found ) {
|
|
switch( authMethod ) {
|
|
case 0:
|
|
break;
|
|
case 4: //Encrypted password ???
|
|
settings.insert( argument, MailTransport::Transport::EnumAuthenticationType::LOGIN ); //????
|
|
kDebug()<<" authmethod == encrypt password";
|
|
break;
|
|
case 5: //GSSAPI
|
|
settings.insert( argument, MailTransport::Transport::EnumAuthenticationType::GSSAPI );
|
|
break;
|
|
case 6: //NTLM
|
|
settings.insert( argument, MailTransport::Transport::EnumAuthenticationType::NTLM );
|
|
break;
|
|
case 7: //TLS
|
|
kDebug()<<" authmethod method == TLS"; //????
|
|
break;
|
|
default:
|
|
kDebug()<<" ThunderbirdSettings::addAuth unknown :"<<authMethod;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ThunderbirdSettings::readAccount()
|
|
{
|
|
Q_FOREACH ( const QString&account, mAccountList )
|
|
{
|
|
const QString serverName = mHashConfig.value( QString::fromLatin1( "mail.account.%1" ).arg( account ) + QLatin1String( ".server" ) ).toString();
|
|
const QString accountName = QString::fromLatin1( "mail.server.%1" ).arg( serverName );
|
|
const QString host = mHashConfig.value( accountName + QLatin1String( ".hostname" ) ).toString();
|
|
const QString userName = mHashConfig.value( accountName + QLatin1String( ".userName" ) ).toString();
|
|
const QString name = mHashConfig.value( accountName + QLatin1String( ".name" ) ).toString();
|
|
|
|
const QString type = mHashConfig.value( accountName + QLatin1String( ".type" ) ).toString();
|
|
//TODO use it ?
|
|
const QString directory = mHashConfig.value( accountName + QLatin1String( ".directory" ) ).toString();
|
|
|
|
const QString loginAtStartupStr = accountName + QLatin1String( ".login_at_startup" );
|
|
bool loginAtStartup = true; //Default for thunderbird;
|
|
if ( mHashConfig.contains( loginAtStartupStr ) ) {
|
|
loginAtStartup = mHashConfig.value( loginAtStartupStr ).toBool();
|
|
}
|
|
bool found = false;
|
|
if ( type == QLatin1String("imap")) {
|
|
QMap<QString, QVariant> settings;
|
|
settings.insert(QLatin1String("ImapServer"),host);
|
|
settings.insert(QLatin1String("UserName"),userName);
|
|
const int port = mHashConfig.value( accountName + QLatin1String( ".port" ) ).toInt( &found);
|
|
if ( found ) {
|
|
settings.insert( QLatin1String( "ImapPort" ), port );
|
|
}
|
|
addAuth( settings, QLatin1String( "Authentication" ), accountName );
|
|
const QString offline = accountName + QLatin1String( ".offline_download" );
|
|
if ( mHashConfig.contains( offline ) ) {
|
|
const bool offlineStatus = mHashConfig.value( offline ).toBool();
|
|
if ( offlineStatus ) {
|
|
settings.insert( QLatin1String( "DisconnectedModeEnabled" ), offlineStatus );
|
|
}
|
|
} else {
|
|
//default value == true
|
|
settings.insert( QLatin1String( "DisconnectedModeEnabled" ), true );
|
|
}
|
|
|
|
found = false;
|
|
const int socketType = mHashConfig.value( accountName + QLatin1String( ".socketType" ) ).toInt( &found);
|
|
if (found) {
|
|
switch(socketType) {
|
|
case 0:
|
|
//None
|
|
settings.insert( QLatin1String( "Safety" ), QLatin1String("None") );
|
|
break;
|
|
case 2:
|
|
//STARTTLS
|
|
settings.insert( QLatin1String( "Safety" ), QLatin1String("STARTTLS") );
|
|
break;
|
|
case 3:
|
|
//SSL/TLS
|
|
settings.insert( QLatin1String( "Safety" ), QLatin1String("SSL") );
|
|
break;
|
|
default:
|
|
kDebug()<<" socketType "<<socketType;
|
|
}
|
|
}
|
|
const QString checkNewMailStr = accountName + QLatin1String( ".check_new_mail" );
|
|
if (mHashConfig.contains(checkNewMailStr)) {
|
|
const bool checkNewMail = mHashConfig.value(checkNewMailStr).toBool();
|
|
settings.insert(QLatin1String("IntervalCheckEnabled"), checkNewMail);
|
|
}
|
|
|
|
const QString checkTimeStr = accountName + QLatin1String( ".check_time" );
|
|
if (mHashConfig.contains(checkTimeStr)) {
|
|
found = false;
|
|
const int checkTime = mHashConfig.value( checkTimeStr ).toInt( &found);
|
|
if (found) {
|
|
settings.insert(QLatin1String("IntervalCheckTime"),checkTime);
|
|
}
|
|
} else {
|
|
//Default value from thunderbird
|
|
settings.insert(QLatin1String("IntervalCheckTime"), 10 );
|
|
}
|
|
const QString trashFolderStr = accountName + QLatin1String( ".trash_folder_name" );
|
|
if (mHashConfig.contains(trashFolderStr)) {
|
|
settings.insert(QLatin1String("TrashCollection"),MailCommon::Util::convertFolderPathToCollectionId(mHashConfig.value(trashFolderStr).toString()));
|
|
}
|
|
|
|
const QString agentIdentifyName = AbstractBase::createResource( QLatin1String("akonadi_imap_resource"), name,settings );
|
|
addCheckMailOnStartup(agentIdentifyName,loginAtStartup);
|
|
//Not find a method to disable it in thunderbird
|
|
addToManualCheck(agentIdentifyName,true);
|
|
} else if ( type == QLatin1String("pop3")) {
|
|
QMap<QString, QVariant> settings;
|
|
settings.insert( QLatin1String( "Host" ), host );
|
|
settings.insert( QLatin1String( "Login" ), userName );
|
|
|
|
const bool leaveOnServer = mHashConfig.value( accountName + QLatin1String( ".leave_on_server")).toBool();
|
|
if (leaveOnServer) {
|
|
settings.insert(QLatin1String("LeaveOnServer"),leaveOnServer);
|
|
}
|
|
|
|
found = false;
|
|
const int numberDayToLeave = mHashConfig.value( accountName + QLatin1String( ".num_days_to_leave_on_server")).toInt(&found);
|
|
if ( found ) {
|
|
settings.insert(QLatin1String("LeaveOnServerDays"),numberDayToLeave);
|
|
}
|
|
|
|
found = false;
|
|
const int port = mHashConfig.value( accountName + QLatin1String( ".port" ) ).toInt( &found);
|
|
if ( found ) {
|
|
settings.insert( QLatin1String( "Port" ), port );
|
|
}
|
|
|
|
found = false;
|
|
const int socketType = mHashConfig.value( accountName + QLatin1String( ".socketType" ) ).toInt( &found);
|
|
if (found) {
|
|
switch(socketType) {
|
|
case 0:
|
|
//None
|
|
//nothing
|
|
break;
|
|
case 2:
|
|
//STARTTLS
|
|
settings.insert( QLatin1String( "UseTLS" ), true );
|
|
break;
|
|
case 3:
|
|
//SSL/TLS
|
|
settings.insert( QLatin1String( "UseSSL" ), true );
|
|
break;
|
|
default:
|
|
kDebug()<<" socketType "<<socketType;
|
|
}
|
|
}
|
|
addAuth( settings, QLatin1String( "AuthenticationMethod" ),accountName );
|
|
const QString checkNewMailStr = accountName + QLatin1String( ".check_new_mail" );
|
|
if (mHashConfig.contains(checkNewMailStr)) {
|
|
const bool checkNewMail = mHashConfig.value(checkNewMailStr).toBool();
|
|
settings.insert(QLatin1String("IntervalCheckEnabled"), checkNewMail);
|
|
}
|
|
const QString checkTimeStr = accountName + QLatin1String( ".check_time" );
|
|
if (mHashConfig.contains(checkTimeStr)) {
|
|
found = false;
|
|
const int checkTime = mHashConfig.value( checkTimeStr ).toInt( &found);
|
|
if (found) {
|
|
settings.insert(QLatin1String("IntervalCheckInterval"),checkTime);
|
|
}
|
|
} else {
|
|
//Default value from thunderbird
|
|
settings.insert(QLatin1String("IntervalCheckInterval"), 10 );
|
|
}
|
|
|
|
const QString agentIdentifyName = AbstractBase::createResource( QLatin1String("akonadi_pop3_resource"), name, settings );
|
|
addCheckMailOnStartup(agentIdentifyName,loginAtStartup);
|
|
//Not find a method to disable it in thunderbird
|
|
addToManualCheck(agentIdentifyName,true);
|
|
} else if ( type == QLatin1String( "none" ) ) {
|
|
//FIXME look at if we can implement it
|
|
kDebug()<<" account type none!";
|
|
} else if (type == QLatin1String("movemail")) {
|
|
kDebug()<<" movemail accound found and not implemented in importthunderbird";
|
|
//TODO
|
|
} else if (type == QLatin1String("rss")) {
|
|
//TODO when akregator2 will merge in kdepim
|
|
kDebug()<<" rss resource needs to be implemented";
|
|
continue;
|
|
} else if (type == QLatin1String("nntp")) {
|
|
//TODO add config directly to knode
|
|
//TODO when knode will merge in kdepim
|
|
kDebug()<<" nntp resource need to be implemented";
|
|
continue;
|
|
} else {
|
|
kDebug()<<" type unknown : "<<type;
|
|
continue;
|
|
}
|
|
|
|
const QString identityConfig = QString::fromLatin1( "mail.account.%1" ).arg( account ) + QLatin1String( ".identities" );
|
|
if ( mHashConfig.contains( identityConfig ) )
|
|
{
|
|
const QStringList idList = mHashConfig.value(identityConfig).toString().split(QLatin1Char(','));
|
|
Q_FOREACH (const QString& id, idList) {
|
|
readIdentity( id );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ThunderbirdSettings::readTransport()
|
|
{
|
|
const QString mailSmtpServer = mHashConfig.value( QLatin1String( "mail.smtpservers" ) ).toString();
|
|
if ( mailSmtpServer.isEmpty() )
|
|
return;
|
|
QStringList smtpList = mailSmtpServer.split( QLatin1Char( ',' ) );
|
|
QString defaultSmtp = mHashConfig.value( QLatin1String( "mail.smtp.defaultserver" ) ).toString();
|
|
if (smtpList.count() == 1 && defaultSmtp.isEmpty())
|
|
{
|
|
//Be sure to define default smtp
|
|
defaultSmtp = smtpList.at(0);
|
|
}
|
|
|
|
Q_FOREACH ( const QString &smtp, smtpList )
|
|
{
|
|
const QString smtpName = QString::fromLatin1( "mail.smtpserver.%1" ).arg( smtp );
|
|
MailTransport::Transport *mt = createTransport();
|
|
const QString name = mHashConfig.value( smtpName + QLatin1String( ".description" ) ).toString();
|
|
mt->setName(name);
|
|
const QString hostName = mHashConfig.value( smtpName + QLatin1String( ".hostname" ) ).toString();
|
|
mt->setHost( hostName );
|
|
|
|
const int port = mHashConfig.value( smtpName + QLatin1String( ".port" ) ).toInt();
|
|
if ( port > 0 )
|
|
mt->setPort( port );
|
|
|
|
const int authMethod = mHashConfig.value( smtpName + QLatin1String( ".authMethod" ) ).toInt();
|
|
switch(authMethod) {
|
|
case 0:
|
|
break;
|
|
case 1: //No authentication
|
|
mt->setAuthenticationType(MailTransport::Transport::EnumAuthenticationType::PLAIN); //????
|
|
break;
|
|
case 3: //Unencrypted password
|
|
mt->setAuthenticationType(MailTransport::Transport::EnumAuthenticationType::CLEAR); //???
|
|
break;
|
|
case 4: //crypted password
|
|
mt->setAuthenticationType(MailTransport::Transport::EnumAuthenticationType::LOGIN); //???
|
|
break;
|
|
case 5: //GSSAPI
|
|
mt->setAuthenticationType(MailTransport::Transport::EnumAuthenticationType::GSSAPI);
|
|
break;
|
|
case 6: //NTLM
|
|
mt->setAuthenticationType(MailTransport::Transport::EnumAuthenticationType::NTLM);
|
|
break;
|
|
default:
|
|
kDebug()<<" authMethod unknown :"<<authMethod;
|
|
}
|
|
|
|
const int trySsl = mHashConfig.value( smtpName + QLatin1String( ".try_ssl" ) ).toInt();
|
|
switch(trySsl) {
|
|
case 0:
|
|
mt->setEncryption( MailTransport::Transport::EnumEncryption::None );
|
|
break;
|
|
case 2:
|
|
mt->setEncryption( MailTransport::Transport::EnumEncryption::TLS );
|
|
break;
|
|
case 3:
|
|
mt->setEncryption( MailTransport::Transport::EnumEncryption::SSL );
|
|
break;
|
|
default:
|
|
kDebug()<<" trySsl unknown :"<<trySsl;
|
|
}
|
|
|
|
const QString userName = mHashConfig.value( smtpName + QLatin1String( ".username" ) ).toString();
|
|
if ( !userName.isEmpty() ) {
|
|
mt->setUserName( userName );
|
|
if (authMethod > 1) {
|
|
mt->setRequiresAuthentication( true );
|
|
}
|
|
}
|
|
|
|
storeTransport( mt, ( smtp == defaultSmtp ) );
|
|
mHashSmtp.insert( smtp, QString::number( mt->id() ) );
|
|
}
|
|
}
|
|
|
|
QString convertThunderbirdPath(const QString& path)
|
|
{
|
|
QString newPath;
|
|
KUrl url(path);
|
|
newPath = url.path();
|
|
newPath.remove(0,1);
|
|
return MailCommon::Util::convertFolderPathToCollectionStr(newPath);
|
|
}
|
|
|
|
void ThunderbirdSettings::readIdentity( const QString& account )
|
|
{
|
|
const QString identity = QString::fromLatin1( "mail.identity.%1" ).arg( account );
|
|
QString fullName = mHashConfig.value( identity + QLatin1String( ".fullName" ) ).toString();
|
|
KPIMIdentities::Identity* newIdentity = createIdentity(fullName);
|
|
|
|
|
|
const QString smtpServer = mHashConfig.value( identity + QLatin1String( ".smtpServer" ) ).toString();
|
|
if (!smtpServer.isEmpty() && mHashSmtp.contains(smtpServer))
|
|
{
|
|
newIdentity->setTransport(mHashSmtp.value(smtpServer));
|
|
}
|
|
|
|
const QString userEmail = mHashConfig.value( identity + QLatin1String( ".useremail" ) ).toString();
|
|
newIdentity->setPrimaryEmailAddress(userEmail);
|
|
|
|
newIdentity->setFullName( fullName );
|
|
newIdentity->setIdentityName( fullName );
|
|
|
|
const QString organization = mHashConfig.value(identity + QLatin1String(".organization")).toString();
|
|
newIdentity->setOrganization(organization);
|
|
|
|
bool doBcc = mHashConfig.value(identity + QLatin1String(".doBcc")).toBool();
|
|
if (doBcc) {
|
|
const QString bcc = mHashConfig.value(identity + QLatin1String(".doBccList")).toString();
|
|
newIdentity->setBcc( bcc );
|
|
}
|
|
|
|
bool doCc = mHashConfig.value(identity + QLatin1String(".doCc")).toBool();
|
|
if (doCc) {
|
|
const QString cc = mHashConfig.value(identity + QLatin1String(".doCcList")).toString();
|
|
newIdentity->setCc( cc );
|
|
}
|
|
|
|
const QString replyTo = mHashConfig.value(identity + QLatin1String( ".reply_to")).toString();
|
|
newIdentity->setReplyToAddr( replyTo );
|
|
|
|
KPIMIdentities::Signature signature;
|
|
const bool signatureHtml = mHashConfig.value(identity + QLatin1String( ".htmlSigFormat" )).toBool();
|
|
if (signatureHtml) {
|
|
signature.setInlinedHtml( true );
|
|
}
|
|
|
|
const bool attachSignature = mHashConfig.value(identity + QLatin1String( ".attach_signature" )).toBool();
|
|
if ( attachSignature ) {
|
|
const QString fileSignature = mHashConfig.value(identity + QLatin1String( ".sig_file")).toString();
|
|
signature.setType( KPIMIdentities::Signature::FromFile );
|
|
signature.setUrl( fileSignature,false );
|
|
}
|
|
else {
|
|
const QString textSignature = mHashConfig.value(identity + QLatin1String( ".htmlSigText" ) ).toString();
|
|
signature.setType( KPIMIdentities::Signature::Inlined );
|
|
signature.setText( textSignature );
|
|
}
|
|
|
|
|
|
if ( mHashConfig.contains( identity + QLatin1String( ".drafts_folder_picker_mode" ) ) )
|
|
{
|
|
const int useSpecificDraftFolder = mHashConfig.value( identity + QLatin1String( ".drafts_folder_picker_mode" ) ).toInt();
|
|
if ( useSpecificDraftFolder == 1 )
|
|
{
|
|
const QString draftFolder = convertThunderbirdPath( mHashConfig.value( identity + QLatin1String( ".draft_folder" ) ).toString() );
|
|
newIdentity->setDrafts( draftFolder );
|
|
}
|
|
}
|
|
|
|
if ( mHashConfig.contains( identity + QLatin1String( ".fcc" ) ) ) {
|
|
const bool fccEnabled = mHashConfig.value(identity + QLatin1String( ".fcc" )).toBool();
|
|
newIdentity->setDisabledFcc( !fccEnabled );
|
|
}
|
|
|
|
//fcc_reply_follows_parent not implemented in kmail
|
|
//fcc_folder_picker_mode is just a flag for thunderbird. Not necessary during import.
|
|
//if ( mHashConfig.contains( identity + QLatin1String( ".fcc_folder_picker_mode" ) ) )
|
|
{
|
|
if (mHashConfig.contains( identity + QLatin1String( ".fcc_folder" ) )) {
|
|
const QString fccFolder = convertThunderbirdPath( mHashConfig.value( identity + QLatin1String( ".fcc_folder" ) ).toString() );
|
|
newIdentity->setFcc( fccFolder );
|
|
}
|
|
}
|
|
|
|
//if ( mHashConfig.contains( identity + QLatin1String( ".tmpl_folder_picker_mode" ) ) )
|
|
{
|
|
if (mHashConfig.contains( identity + QLatin1String( ".stationery_folder" ) )) {
|
|
const QString templateFolder = convertThunderbirdPath( mHashConfig.value( identity + QLatin1String( ".stationery_folder" ) ).toString() );
|
|
newIdentity->setTemplates( templateFolder );
|
|
}
|
|
}
|
|
|
|
const QString attachVcardStr( identity + QLatin1String( ".attach_vcard" ) );
|
|
if ( mHashConfig.contains( attachVcardStr ) ) {
|
|
const bool attachVcard = mHashConfig.value( attachVcardStr ).toBool();
|
|
newIdentity->setAttachVcard(attachVcard);
|
|
}
|
|
const QString attachVcardContentStr( identity + QLatin1String( ".escapedVCard" ) );
|
|
if ( mHashConfig.contains( attachVcardContentStr ) ) {
|
|
const QString str = mHashConfig.value( attachVcardContentStr ).toString();
|
|
QByteArray vcard = QByteArray::fromPercentEncoding ( str.toLocal8Bit() );
|
|
KABC::VCardConverter converter;
|
|
KABC::Addressee addr = converter.parseVCard( vcard );
|
|
|
|
const QString filename = KStandardDirs::locateLocal("appdata",newIdentity->identityName() + QLatin1String(".vcf"));
|
|
QFile file(filename);
|
|
if ( file.open( QIODevice::WriteOnly |QIODevice::Text ) ) {
|
|
const QByteArray data = converter.exportVCard( addr, KABC::VCardConverter::v3_0 );
|
|
file.write( data );
|
|
file.flush();
|
|
file.close();
|
|
newIdentity->setVCardFile(filename);
|
|
}
|
|
}
|
|
const QString signMailStr( identity + QLatin1String( ".sign_mail" ) );
|
|
if ( mHashConfig.contains( signMailStr ) ) {
|
|
const bool signMail = mHashConfig.value(signMailStr).toBool();
|
|
newIdentity->setPgpAutoSign(signMail);
|
|
}
|
|
|
|
const QString composeHtmlStr( identity + QLatin1String( ".compose_html" ) );
|
|
//TODO: implement it in kmail
|
|
|
|
newIdentity->setSignature( signature );
|
|
|
|
storeIdentity(newIdentity);
|
|
}
|
|
|
|
void ThunderbirdSettings::insertIntoMap( const QString& line )
|
|
{
|
|
QString newLine = line;
|
|
newLine.remove( QLatin1String( "user_pref(\"" ) );
|
|
newLine.remove( QLatin1String( ");" ) );
|
|
const int pos = newLine.indexOf( QLatin1Char( ',' ) );
|
|
QString key = newLine.left( pos );
|
|
key.remove( key.length() -1, 1 );
|
|
QString valueStr = newLine.right( newLine.length() - pos -2);
|
|
if ( valueStr.at( 0 ) == QLatin1Char( '"' ) ) {
|
|
valueStr.remove( 0, 1 );
|
|
const int pos(valueStr.length()-1);
|
|
if ( valueStr.at( pos ) == QLatin1Char( '"' ) )
|
|
valueStr.remove( pos, 1 );
|
|
//Store as String
|
|
mHashConfig.insert( key, valueStr );
|
|
} else {
|
|
if ( valueStr == QLatin1String( "true" ) ) {
|
|
mHashConfig.insert( key, true );
|
|
} else if ( valueStr == QLatin1String( "false" ) ) {
|
|
mHashConfig.insert( key, false );
|
|
} else {
|
|
//Store as integer
|
|
const int value = valueStr.toInt();
|
|
mHashConfig.insert( key, value );
|
|
}
|
|
}
|
|
if (key.contains(QLatin1String("ldap_")) && key.endsWith(QLatin1String(".description"))) {
|
|
QString ldapAccountName = key;
|
|
mLdapAccountList.append(ldapAccountName.remove(QLatin1String(".description")));
|
|
}
|
|
if (key.contains(QLatin1String("mailnews.tags.")) &&
|
|
(key.endsWith(QLatin1String(".color")) || key.endsWith(QLatin1String(".tag")))) {
|
|
QString name = key;
|
|
name.remove(QLatin1String("mailnews.tags."));
|
|
name.remove(QLatin1String(".color"));
|
|
name.remove(QLatin1String(".tag"));
|
|
tagStruct tag;
|
|
if (mHashTag.contains(name)) {
|
|
tag = mHashTag.value(name);
|
|
mHashTag.remove(name);
|
|
}
|
|
if (key.endsWith(QLatin1String(".color"))) {
|
|
tag.color = QColor(mHashConfig.value(key).toString());
|
|
} else {
|
|
tag.name = mHashConfig.value(key).toString();
|
|
}
|
|
mHashTag.insert(name,tag);
|
|
kDebug()<<" tag :"<<name<<" tag.name"<<tag.name<<" color :"<<tag.color;
|
|
}
|
|
}
|
|
|
|
void ThunderbirdSettings::addNewMailNotifier(const QString &group, const QString &key, bool value)
|
|
{
|
|
KConfig config(QLatin1String("akonadi_newmailnotifier_agentrc"));
|
|
KConfigGroup grp = config.group(group);
|
|
grp.writeEntry(key, value);
|
|
}
|