00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
#include "enum.h"
00034
00035
#include <klocale.h>
00036
00037
#include <qstring.h>
00038
#include <qstringlist.h>
00039
00040
static const struct {
00041 Kleo::CryptoMessageFormat format;
00042
const char * displayName;
00043
const char * configName;
00044 } cryptoMessageFormats[] = {
00045 { Kleo::InlineOpenPGPFormat,
00046 I18N_NOOP(
"Inline OpenPGP (deprecated)"),
00047
"inline openpgp" },
00048 { Kleo::OpenPGPMIMEFormat,
00049 I18N_NOOP(
"OpenPGP/MIME"),
00050
"openpgp/mime" },
00051 { Kleo::SMIMEFormat,
00052 I18N_NOOP(
"S/MIME"),
00053
"s/mime" },
00054 { Kleo::SMIMEOpaqueFormat,
00055 I18N_NOOP(
"S/MIME opaque"),
00056
"s/mime opaque" },
00057 };
00058
static const unsigned int numCryptoMessageFormats
00059 =
sizeof cryptoMessageFormats /
sizeof *cryptoMessageFormats ;
00060
00061
const char * Kleo::cryptoMessageFormatToString( Kleo::CryptoMessageFormat f ) {
00062
if ( f == AutoFormat )
00063
return "auto";
00064
for (
unsigned int i = 0 ; i < numCryptoMessageFormats ; ++i )
00065
if ( f == cryptoMessageFormats[i].format )
00066
return cryptoMessageFormats[i].configName;
00067
return 0;
00068 }
00069
00070
QStringList Kleo::cryptoMessageFormatsToStringList(
unsigned int f ) {
00071
QStringList result;
00072
for (
unsigned int i = 0 ; i < numCryptoMessageFormats ; ++i )
00073
if ( f & cryptoMessageFormats[i].format )
00074 result.push_back( cryptoMessageFormats[i].configName );
00075
return result;
00076 }
00077
00078
QString Kleo::cryptoMessageFormatToLabel( Kleo::CryptoMessageFormat f ) {
00079
if ( f == AutoFormat )
00080
return i18n(
"Any");
00081
for (
unsigned int i = 0 ; i < numCryptoMessageFormats ; ++i )
00082
if ( f == cryptoMessageFormats[i].format )
00083
return i18n( cryptoMessageFormats[i].displayName );
00084
return QString::null;
00085 }
00086
00087 Kleo::CryptoMessageFormat Kleo::stringToCryptoMessageFormat(
const QString & s ) {
00088
const QString t = s.lower();
00089
for (
unsigned int i = 0 ; i < numCryptoMessageFormats ; ++i )
00090
if ( t == cryptoMessageFormats[i].configName )
00091
return cryptoMessageFormats[i].format;
00092
return AutoFormat;
00093 }
00094
00095
unsigned int Kleo::stringListToCryptoMessageFormats(
const QStringList & sl ) {
00096
unsigned int result = 0;
00097
for ( QStringList::const_iterator it = sl.begin() ; it != sl.end() ; ++it )
00098 result |= stringToCryptoMessageFormat( *it );
00099
return result;
00100 }
00101
00102
00103
00104
const char* Kleo::encryptionPreferenceToString( EncryptionPreference pref )
00105 {
00106
switch( pref ) {
00107
case UnknownPreference:
00108
return 0;
00109
case NeverEncrypt:
00110
return "never";
00111
case AlwaysEncrypt:
00112
return "always";
00113
case AlwaysEncryptIfPossible:
00114
return "alwaysIfPossible";
00115
case AlwaysAskForEncryption:
00116
return "askAlways";
00117
case AskWheneverPossible:
00118
return "askWhenPossible";
00119 }
00120
return 0;
00121 }
00122
00123 Kleo::EncryptionPreference Kleo::stringToEncryptionPreference(
const QString& str )
00124 {
00125
if ( str ==
"never" )
00126
return NeverEncrypt;
00127
if ( str ==
"always" )
00128
return AlwaysEncrypt;
00129
if ( str ==
"alwaysIfPossible" )
00130
return AlwaysEncryptIfPossible;
00131
if ( str ==
"askAlways" )
00132
return AlwaysAskForEncryption;
00133
if ( str ==
"askWhenPossible" )
00134
return AskWheneverPossible;
00135
return UnknownPreference;
00136 }
00137
00138
QString Kleo::encryptionPreferenceToLabel( EncryptionPreference pref )
00139 {
00140
switch( pref ) {
00141
case NeverEncrypt:
00142
return i18n(
"Never Encrypt" );
00143
case AlwaysEncrypt:
00144
return i18n(
"Always Encrypt" );
00145
case AlwaysEncryptIfPossible:
00146
return i18n(
"Always Encrypt If Possible" );
00147
case AlwaysAskForEncryption:
00148
return i18n(
"Ask" );
00149
case AskWheneverPossible:
00150
return i18n(
"Ask Whenever Possible" );
00151
default:
00152
return i18n(
"no specific preference",
"<none>" );
00153 }
00154 }
00155
00156
const char* Kleo::signingPreferenceToString( SigningPreference pref )
00157 {
00158
switch( pref ) {
00159
case UnknownSigningPreference:
00160
return 0;
00161
case NeverSign:
00162
return "never";
00163
case AlwaysSign:
00164
return "always";
00165
case AlwaysSignIfPossible:
00166
return "alwaysIfPossible";
00167
case AlwaysAskForSigning:
00168
return "askAlways";
00169
case AskSigningWheneverPossible:
00170
return "askWhenPossible";
00171 }
00172
return 0;
00173 }
00174
00175 Kleo::SigningPreference Kleo::stringToSigningPreference(
const QString& str )
00176 {
00177
if ( str ==
"never" )
00178
return NeverSign;
00179
if ( str ==
"always" )
00180
return AlwaysSign;
00181
if ( str ==
"alwaysIfPossible" )
00182
return AlwaysSignIfPossible;
00183
if ( str ==
"askAlways" )
00184
return AlwaysAskForSigning;
00185
if ( str ==
"askWhenPossible" )
00186
return AskSigningWheneverPossible;
00187
return UnknownSigningPreference;
00188 }
00189
00190
QString Kleo::signingPreferenceToLabel( SigningPreference pref )
00191 {
00192
switch( pref ) {
00193
case NeverSign:
00194
return i18n(
"Never Sign" );
00195
case AlwaysSign:
00196
return i18n(
"Always Sign" );
00197
case AlwaysSignIfPossible:
00198
return i18n(
"Always Sign If Possible" );
00199
case AlwaysAskForSigning:
00200
return i18n(
"Ask" );
00201
case AskSigningWheneverPossible:
00202
return i18n(
"Ask Whenever Possible" );
00203
default:
00204
return i18n(
"no specific preference",
"<none>" );
00205 }
00206 }