kernel/qkeysequence.cpp

d = new QKeySequencePrivate();

executed: }

Execution Count:55

909 else -

910

executed: d = new QKeySequencePrivate();

Execution Count:2

911 } -

912 -

913 -

914 /*! -

915 Constructs an empty key sequence. -

916 */ -

917 QKeySequence::QKeySequence() -

918 { -

919 static QKeySequencePrivate shared_empty; -

920

d = &shared_empty;

executed (the execution status of this line is deduced): d = &shared_empty;

921

d->ref.ref();

executed (the execution status of this line is deduced): d->ref.ref();

922

d = new QKeySequencePrivate();

executed: }

Execution Count:15485

15485

923 -

924 /*! -

925 Creates a key sequence from the \a key string, based on \a format. -

926 -

927 For example "Ctrl+O" gives CTRL+'O'. The strings "Ctrl", -

928 "Shift", "Alt" and "Meta" are recognized, as well as their -

929 translated equivalents in the "QShortcut" context (using -

930 QObject::tr()). -

931 -

932 Up to four key codes may be entered by separating them with -

933 commas, e.g. "Alt+X,Ctrl+S,Q". -

934 -

935 This constructor is typically used with \l{QObject::tr()}{tr}(), so -

936 that shortcut keys can be replaced in translations: -

937 -

938 \snippet code/src_gui_kernel_qkeysequence.cpp 2 -

939 -

940 Note the "File|Open" translator comment. It is by no means -

941 necessary, but it provides some context for the human translator. -

942 */ -

943 QKeySequence::QKeySequence(const QString &key, QKeySequence::SequenceFormat format) -

944 { -

945

executed (the execution status of this line is deduced): d = new QKeySequencePrivate();

946

assign(key, format);

executed (the execution status of this line is deduced): assign(key, format);

947

d = new QKeySequencePrivate();

executed: }

Execution Count:664

664

948 -

949 /*! -

950 Constructs a key sequence with up to 4 keys \a k1, \a k2, -

951 \a k3 and \a k4. -

952 -

953 The key codes are listed in Qt::Key and can be combined with -

954 modifiers (see Qt::Modifier) such as Qt::SHIFT, Qt::CTRL, -

955 Qt::ALT, or Qt::META. -

956 */ -

957 QKeySequence::QKeySequence(int k1, int k2, int k3, int k4) -

958 { -

959

executed (the execution status of this line is deduced): d = new QKeySequencePrivate();

960

d->key[0] = k1;

executed (the execution status of this line is deduced): d->key[0] = k1;

961

d->key[1] = k2;

executed (the execution status of this line is deduced): d->key[1] = k2;

962

d->key[2] = k3;

executed (the execution status of this line is deduced): d->key[2] = k3;

963

d->key[3] = k4;

executed (the execution status of this line is deduced): d->key[3] = k4;

964

executed: }

Execution Count:3534

3534

965 -

966 /*! -

967 Copy constructor. Makes a copy of \a keysequence. -

968 */ -

969 QKeySequence::QKeySequence(const QKeySequence& keysequence) -

970 : d(keysequence.d) -

971 { -

972

d->ref.ref();

executed (the execution status of this line is deduced): d->ref.ref();

973

const uint platform = QKeySequencePrivate::currentKeyPlatforms();

executed: }

Execution Count:10987

10987

974 -

975 #if defined(Q_OS_MAC) && !defined(Q_OS_IOS) -

976 static inline int maybeSwapShortcut(int shortcut) -

977 { -

978 if (qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta)) { -

979 uint oldshortcut = shortcut; -

980 shortcut &= ~(Qt::CTRL | Qt::META); -

981 if (oldshortcut & Qt::CTRL) -

982 shortcut |= Qt::META; -

983 if (oldshortcut & Qt::META) -

984 shortcut |= Qt::CTRL; -

985 } -

986 return shortcut; -

987 } -

988 #endif -

989 -

990 /*! -

991 \since 4.2 -

992 -

993 Returns a list of key bindings for the given \a key. -

994 The result of calling this function will vary based on the target platform. -

995 The first element of the list indicates the primary shortcut for the given platform. -

996 If the result contains more than one result, these can -

997 be considered alternative shortcuts on the same platform for the given \a key. -

998 */ -

999 QList<QKeySequence> QKeySequence::keyBindings(StandardKey key) -

1000 { -

1001

executed (the execution status of this line is deduced): const uint platform = QKeySequencePrivate::currentKeyPlatforms();

1002

QList <QKeySequence> list;

executed (the execution status of this line is deduced): QList <QKeySequence> list;

1003

for (uint i = 0; i < QKeySequencePrivate::numberOfKeyBindings ; ++i) {

evaluated: i < QKeySequencePrivate::numberOfKeyBindings

TRUE	FALSE
yes Evaluation Count:24150	yes Evaluation Count:161

161-24150

1004

QKeyBinding keyBinding = QKeySequencePrivate::keyBindings[i];

executed (the execution status of this line is deduced): QKeyBinding keyBinding = QKeySequencePrivate::keyBindings[i];

1005

if (keyBinding.standardKey == key && (keyBinding.platform & platform)) {

evaluated: keyBinding.standardKey == key

TRUE	FALSE
yes Evaluation Count:567	yes Evaluation Count:23583

evaluated: (keyBinding.platform & platform)

TRUE	FALSE
yes Evaluation Count:211	yes Evaluation Count:356

211-23583

1006

uint shortcut =

executed (the execution status of this line is deduced): uint shortcut =

1007

#if defined(Q_OS_MAC) && !defined(Q_OS_IOS)

executed (the execution status of this line is deduced):

1008

maybeSwapShortcut(QKeySequencePrivate::keyBindings[i].shortcut);

executed (the execution status of this line is deduced):

1009

#else

executed (the execution status of this line is deduced):

1010

QKeySequencePrivate::keyBindings[i].shortcut;

executed (the execution status of this line is deduced): QKeySequencePrivate::keyBindings[i].shortcut;

1011 #endif -

1012

if (keyBinding.priority > 0)

evaluated: keyBinding.priority > 0

TRUE	FALSE
yes Evaluation Count:44	yes Evaluation Count:167

44-167

1013

list.prepend(QKeySequence(shortcut));

executed: list.prepend(QKeySequence(shortcut));

Execution Count:44

1014 else -

1015

list.append(QKeySequence(shortcut));

executed: list.append(QKeySequence(shortcut));

Execution Count:167

167

1016 } -

1017

executed: }

Execution Count:24150

24150

1018

return list;

executed: return list;

Execution Count:161

161

1019 } -

1020 -

1021 /*! -

1022 Destroys the key sequence. -

1023 */ -

1024 QKeySequence::~QKeySequence() -

1025 { -

1026

if (!d->ref.deref())

evaluated: !d->ref.deref()

TRUE	FALSE
yes Evaluation Count:4388	yes Evaluation Count:26207

4388-26207

1027

delete d;

executed: delete d;

Execution Count:4388

4388

1028

Q_ASSERT_X(index >= 0 && index < 4, "QKeySequence::setKey", "index out of range");

executed: }

Execution Count:30595

30595

1029 -

1030 /*! -

1031 \internal -

1032 KeySequences should never be modified, but rather just created. -

1033 Internally though we do need to modify to keep pace in event -

1034 delivery. -

1035 */ -

1036 -

1037 void QKeySequence::setKey(int key, int index) -

1038 { -

1039

executed (the execution status of this line is deduced): qt_noop();

1040

qAtomicDetach(d);

executed (the execution status of this line is deduced): qAtomicDetach(d);

1041

d->key[index] = key;

executed (the execution status of this line is deduced): d->key[index] = key;

1042

if(qt_sequence_no_mnemonics)

executed: }

Execution Count:1180

1180

1043 -

1044 /*! -

1045 Returns the number of keys in the key sequence. -

1046 The maximum is 4. -

1047 */ -

1048 int QKeySequence::count() const -

1049 { -

1050

if (!d->key[0])

evaluated: !d->key[0]

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:1169

3-1169

1051

return 0;

executed: return 0;

Execution Count:3

1052

if (!d->key[1])

evaluated: !d->key[1]

TRUE	FALSE
yes Evaluation Count:1126	yes Evaluation Count:43

43-1126

1053

return 1;

executed: return 1;

Execution Count:1126

1126

1054

if (!d->key[2])

evaluated: !d->key[2]

TRUE	FALSE
yes Evaluation Count:40	yes Evaluation Count:3

3-40

1055

return 2;

executed: return 2;

Execution Count:40

1056

if (!d->key[3])

partially evaluated: !d->key[3]

TRUE	FALSE
yes Evaluation Count:3	no Evaluation Count:0

0-3

1057

return 3;

executed: return 3;

Execution Count:3

1058

return 4;

never executed: return 4;

1059 } -

1060 -

1061 -

1062 /*! -

1063 Returns true if the key sequence is empty; otherwise returns -

1064 false. -

1065 */ -

1066 bool QKeySequence::isEmpty() const -

1067 { -

1068

return !d->key[0];

executed: return !d->key[0];

Execution Count:12053

12053

1069 } -

1070 -

1071 -

1072 /*! -

1073 Returns the shortcut key sequence for the mnemonic in \a text, -

1074 or an empty key sequence if no mnemonics are found. -

1075 -

1076 For example, mnemonic("E&xit") returns \c{Qt::ALT+Qt::Key_X}, -

1077 mnemonic("&Quit") returns \c{ALT+Key_Q}, and mnemonic("Quit") -

1078 returns an empty QKeySequence. -

1079 -

1080 We provide a \l{accelerators.html}{list of common mnemonics} -

1081 in English. At the time of writing, Microsoft and Open Group do -

1082 not appear to have issued equivalent recommendations for other -

1083 languages. -

1084 -

1085 \sa qt_set_sequence_auto_mnemonic() -

1086 */ -

1087 QKeySequence QKeySequence::mnemonic(const QString &text) -

1088 { -

1089

QKeySequence ret;

executed (the execution status of this line is deduced): QKeySequence ret;

1090 -

1091

partially evaluated: qt_sequence_no_mnemonics

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:3565

0-3565

1092

p = text.indexOf(QLatin1Char('&'), p) + 1;

never executed: return ret;

1093 -

1094

bool found = false;

executed (the execution status of this line is deduced): bool found = false;

1095

int p = 0;

executed (the execution status of this line is deduced): int p = 0;

1096

while (p >= 0) {

partially evaluated: p >= 0

TRUE	FALSE
yes Evaluation Count:3578	no Evaluation Count:0

0-3578

1097

executed (the execution status of this line is deduced): p = text.indexOf(QLatin1Char('&'), p) + 1;

1098

if (p <= 0 || p >= (int)text.length())

evaluated: p <= 0

TRUE	FALSE
yes Evaluation Count:1967	yes Evaluation Count:1611

evaluated: p >= (int)text.length()

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:1609

2-1967

1099

if (text.at(p) != QLatin1Char('&')) {

executed: break;

Execution Count:1969

1969

1100

evaluated: text.at(p) != QLatin1Char('&')

TRUE	FALSE
yes Evaluation Count:1596	yes Evaluation Count:13

13-1596

1101

QChar c = text.at(p);

executed (the execution status of this line is deduced): QChar c = text.at(p);

1102

if (c.isPrint()) {

partially evaluated: c.isPrint()

TRUE	FALSE
yes Evaluation Count:1596	no Evaluation Count:0

0-1596

1103

if (!found) {

partially evaluated: !found

TRUE	FALSE
yes Evaluation Count:1596	no Evaluation Count:0

0-1596

1104

c = c.toUpper();

executed (the execution status of this line is deduced): c = c.toUpper();

1105

ret = QKeySequence(c.unicode() + Qt::ALT);

executed (the execution status of this line is deduced): ret = QKeySequence(c.unicode() + Qt::ALT);

1106 #ifdef QT_NO_DEBUG -

1107

executed: return ret;

Execution Count:1596

1596

1108 #else -

1109 found = true; -

1110 } else { -

1111 qWarning("QKeySequence::mnemonic: \"%s\" contains multiple occurrences of '&'", qPrintable(text)); -

1112 #endif -

1113 } -

never executed: }

never executed: }

executed (the execution status of this line is deduced): p++;

1117

executed: }

Execution Count:13

1118

return assign(ks, NativeText);

executed: return ret;

Execution Count:1969

1969

1119 } -

1120 -

1121 /*! -

1122 \fn int QKeySequence::assign(const QString &keys) -

1123 -

1124 Adds the given \a keys to the key sequence. \a keys may -

1125 contain up to four key codes, provided they are separated by a -

1126 comma; for example, "Alt+X,Ctrl+S,Z". The return value is the -

1127 number of key codes added. -

1128 \a keys should be in NativeText format. -

1129 */ -

1130 int QKeySequence::assign(const QString &ks) -

1131 { -

1132

never executed: return assign(ks, NativeText);

1133 } -

1134 -

1135 /*! -

1136 \fn int QKeySequence::assign(const QString &keys, QKeySequence::SequenceFormat format) -

1137 \since 4.7 -

1138 -

1139 Adds the given \a keys to the key sequence (based on \a format). -

1140 \a keys may contain up to four key codes, provided they are -

1141 separated by a comma; for example, "Alt+X,Ctrl+S,Z". The return -

1142 value is the number of key codes added. -

1143 */ -

1144 int QKeySequence::assign(const QString &ks, QKeySequence::SequenceFormat format) -

1145 { -

1146

QString keyseq = ks;

executed (the execution status of this line is deduced): QString keyseq = ks;

1147

QString part;

executed (the execution status of this line is deduced): QString part;

1148

int n = 0;

executed (the execution status of this line is deduced): int n = 0;

1149

int p = 0, diff = 0;

executed (the execution status of this line is deduced): int p = 0, diff = 0;

1150 -

1151 // Run through the whole string, but stop -

1152 // if we have 4 keys before the end. -

1153

while (keyseq.length() && n < 4) {

evaluated: keyseq.length()

TRUE	FALSE
yes Evaluation Count:689	yes Evaluation Count:664

partially evaluated: n < 4

TRUE	FALSE
yes Evaluation Count:689	no Evaluation Count:0

0-689

1154 // We MUST use something to separate each sequence, and space -

1155 // does not cut it, since some of the key names have space -

1156 // in them.. (Let's hope no one translate with a comma in it:) -

1157

p = keyseq.indexOf(QLatin1Char(','));

executed (the execution status of this line is deduced): p = keyseq.indexOf(QLatin1Char(','));

1158

if (-1 != p) {

evaluated: -1 != p

TRUE	FALSE
yes Evaluation Count:42	yes Evaluation Count:647

42-647

1159

if (p == keyseq.count() - 1) { // Last comma 'Ctrl+,'

evaluated: p == keyseq.count() - 1

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:31

11-31

1160

p = -1;

executed (the execution status of this line is deduced): p = -1;

1161

if (QLatin1Char(',') == keyseq.at(p+1)) // e.g. 'Ctrl+,, Shift+,,'

executed: }

Execution Count:11

1162

evaluated: QLatin1Char(',') == keyseq.at(p+1)

TRUE	FALSE
yes Evaluation Count:13	yes Evaluation Count:18

13-18

1163

p++;

executed: p++;

Execution Count:13

1164

if (QLatin1Char(' ') == keyseq.at(p+1)) { // Space after comma

evaluated: QLatin1Char(' ') == keyseq.at(p+1)

TRUE	FALSE
yes Evaluation Count:27	yes Evaluation Count:4

4-27

1165

diff = 1;

executed (the execution status of this line is deduced): diff = 1;

1166

p++;

executed (the execution status of this line is deduced): p++;

1167

executed: }

Execution Count:27

1168

diff = 0;

executed (the execution status of this line is deduced): diff = 0;

1169

part = keyseq.left(-1 == p ? keyseq.length() : p - diff);

executed: }

Execution Count:4

1170 } -

1171 } -

1172

executed (the execution status of this line is deduced): part = keyseq.left(-1 == p ? keyseq.length() : p - diff);

1173

keyseq = keyseq.right(-1 == p ? 0 : keyseq.length() - (p + 1));

executed (the execution status of this line is deduced): keyseq = keyseq.right(-1 == p ? 0 : keyseq.length() - (p + 1));

1174

d->key[n] = QKeySequencePrivate::decodeString(part, format);

executed (the execution status of this line is deduced): d->key[n] = QKeySequencePrivate::decodeString(part, format);

1175

++n;

executed (the execution status of this line is deduced): ++n;

1176

QModifKeyName(int q, QChar n) : qt_key(q), name(n) { }

executed: }

Execution Count:689

689

1177

return n;

executed: return n;

Execution Count:664

664

1178 } -

1179 -

1180 struct QModifKeyName { -

1181 QModifKeyName() { } -

1182

never executed: }

1183

QModifKeyName(int q, const QString &n) : qt_key(q), name(n) { }

executed: }

Execution Count:2680

2680

1184 int qt_key; -

1185 QString name; -

1186 }; -

1187 -

1188

Q_GLOBAL_STATIC(QList<QModifKeyName>, globalModifs)

never executed: delete x;

executed: return thisGlobalStatic.pointer.load();

Execution Count:657

partially evaluated: !thisGlobalStatic.pointer.testAndSetOrdered(0, x)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12

evaluated: !thisGlobalStatic.pointer.load()

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:645

partially evaluated: !thisGlobalStatic.destroyed

TRUE	FALSE
yes Evaluation Count:12	no Evaluation Count:0

0-657

1189

Q_GLOBAL_STATIC(QList<QModifKeyName>, globalPortableModifs)

never executed: delete x;

executed: return thisGlobalStatic.pointer.load();

Execution Count:32

partially evaluated: !thisGlobalStatic.pointer.testAndSetOrdered(0, x)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

evaluated: !thisGlobalStatic.pointer.load()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:31

partially evaluated: !thisGlobalStatic.destroyed

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

0-32

1190 -

1191 /*! -

1192 Constructs a single key from the string \a str. -

1193 */ -

1194 int QKeySequence::decodeString(const QString &str) -

1195 { -

1196

return QKeySequencePrivate::decodeString(str, NativeText);

never executed: return QKeySequencePrivate::decodeString(str, NativeText);

1197 } -

1198 -

1199 int QKeySequencePrivate::decodeString(const QString &str, QKeySequence::SequenceFormat format) -

1200 { -

1201

int ret = 0;

executed (the execution status of this line is deduced): int ret = 0;

1202

QString accel = str.toLower();

executed (the execution status of this line is deduced): QString accel = str.toLower();

1203

bool nativeText = (format == QKeySequence::NativeText);

executed (the execution status of this line is deduced): bool nativeText = (format == QKeySequence::NativeText);

1204 -

1205

QList<QModifKeyName> *gmodifs;

executed (the execution status of this line is deduced): QList<QModifKeyName> *gmodifs;

1206

if (nativeText) {

evaluated: nativeText

TRUE	FALSE
yes Evaluation Count:657	yes Evaluation Count:32

32-657

1207

gmodifs = globalModifs();

executed (the execution status of this line is deduced): gmodifs = globalModifs();

1208

if (gmodifs->isEmpty()) {

evaluated: gmodifs->isEmpty()

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:645

12-645

1209 #if defined(Q_OS_MAC) && !defined(Q_OS_IOS) -

1210 const bool dontSwap = qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta); -

1211 if (dontSwap) -

1212 *gmodifs << QModifKeyName(Qt::META, QChar(kCommandUnicode)); -

1213 else -

1214 *gmodifs << QModifKeyName(Qt::CTRL, QChar(kCommandUnicode)); -

1215 *gmodifs << QModifKeyName(Qt::ALT, QChar(kOptionUnicode)); -

1216 if (dontSwap) -

1217 *gmodifs << QModifKeyName(Qt::CTRL, QChar(kControlUnicode)); -

1218 else -

1219 *gmodifs << QModifKeyName(Qt::META, QChar(kControlUnicode)); -

1220 *gmodifs << QModifKeyName(Qt::SHIFT, QChar(kShiftUnicode)); -

1221 #endif -

1222

*gmodifs << QModifKeyName(Qt::CTRL, QLatin1String("ctrl+"))

executed (the execution status of this line is deduced): *gmodifs << QModifKeyName(Qt::CTRL, QLatin1String("ctrl+"))

1223

<< QModifKeyName(Qt::SHIFT, QLatin1String("shift+"))

executed (the execution status of this line is deduced): << QModifKeyName(Qt::SHIFT, QLatin1String("shift+"))

1224

<< QModifKeyName(Qt::ALT, QLatin1String("alt+"))

executed (the execution status of this line is deduced): << QModifKeyName(Qt::ALT, QLatin1String("alt+"))

1225

<< QModifKeyName(Qt::META, QLatin1String("meta+"));

executed (the execution status of this line is deduced): << QModifKeyName(Qt::META, QLatin1String("meta+"));

1226

executed: }

Execution Count:12

1227

gmodifs = globalPortableModifs();

executed: }

Execution Count:657

657

1228

executed (the execution status of this line is deduced): gmodifs = globalPortableModifs();

1229

if (gmodifs->isEmpty()) {

evaluated: gmodifs->isEmpty()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:31

1-31

1230

*gmodifs << QModifKeyName(Qt::CTRL, QLatin1String("ctrl+"))

executed (the execution status of this line is deduced): *gmodifs << QModifKeyName(Qt::CTRL, QLatin1String("ctrl+"))

1231

<< QModifKeyName(Qt::SHIFT, QLatin1String("shift+"))

executed (the execution status of this line is deduced): << QModifKeyName(Qt::SHIFT, QLatin1String("shift+"))

1232

<< QModifKeyName(Qt::ALT, QLatin1String("alt+"))

executed (the execution status of this line is deduced): << QModifKeyName(Qt::ALT, QLatin1String("alt+"))

1233

<< QModifKeyName(Qt::META, QLatin1String("meta+"));

executed (the execution status of this line is deduced): << QModifKeyName(Qt::META, QLatin1String("meta+"));

1234

executed: }

Execution Count:1

1235

if (!gmodifs) return ret;

executed: }

Execution Count:32

1236

never executed: return ret;

partially evaluated: !gmodifs

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:689

0-689

1237 -

1238 -

1239

QList<QModifKeyName> modifs;

executed (the execution status of this line is deduced): QList<QModifKeyName> modifs;

1240

if (nativeText) {

evaluated: nativeText

TRUE	FALSE
yes Evaluation Count:657	yes Evaluation Count:32

32-657

1241

modifs << QModifKeyName(Qt::CTRL, QCoreApplication::translate("QShortcut", "Ctrl").toLower().append(QLatin1Char('+')))

executed (the execution status of this line is deduced): modifs << QModifKeyName(Qt::CTRL, QCoreApplication::translate("QShortcut", "Ctrl").toLower().append(QLatin1Char('+')))

1242

<< QModifKeyName(Qt::SHIFT, QCoreApplication::translate("QShortcut", "Shift").toLower().append(QLatin1Char('+')))

executed (the execution status of this line is deduced): << QModifKeyName(Qt::SHIFT, QCoreApplication::translate("QShortcut", "Shift").toLower().append(QLatin1Char('+')))

1243

<< QModifKeyName(Qt::ALT, QCoreApplication::translate("QShortcut", "Alt").toLower().append(QLatin1Char('+')))

executed (the execution status of this line is deduced): << QModifKeyName(Qt::ALT, QCoreApplication::translate("QShortcut", "Alt").toLower().append(QLatin1Char('+')))

1244

<< QModifKeyName(Qt::META, QCoreApplication::translate("QShortcut", "Meta").toLower().append(QLatin1Char('+')));

executed (the execution status of this line is deduced): << QModifKeyName(Qt::META, QCoreApplication::translate("QShortcut", "Meta").toLower().append(QLatin1Char('+')));

1245

modifs += *gmodifs; // Test non-translated ones last

executed: }

Execution Count:657

657

1246

executed (the execution status of this line is deduced): modifs += *gmodifs;

1247 -

1248

QString sl = accel;

executed (the execution status of this line is deduced): QString sl = accel;

1249 #if defined(Q_OS_MAC) && !defined(Q_OS_IOS) -

1250 for (int i = 0; i < modifs.size(); ++i) { -

1251 const QModifKeyName &mkf = modifs.at(i); -

1252 if (sl.contains(mkf.name)) { -

1253 ret |= mkf.qt_key; -

1254 accel.remove(mkf.name); -

1255 sl = accel; -

1256 } -

1257 } -

1258 #else -

1259

int i = 0;

executed (the execution status of this line is deduced): int i = 0;

1260

int lastI = 0;

executed (the execution status of this line is deduced): int lastI = 0;

1261

while ((i = sl.indexOf(QLatin1Char('+'), i + 1)) != -1) {

evaluated: (i = sl.indexOf(QLatin1Char('+'), i + 1)) != -1

TRUE	FALSE
yes Evaluation Count:269	yes Evaluation Count:673

269-673

1262

const QString sub = sl.mid(lastI, i - lastI + 1);

executed (the execution status of this line is deduced): const QString sub = sl.mid(lastI, i - lastI + 1);

1263 // If we get here the shortcuts contains at least one '+'. We break up -

1264 // along the following strategy: -

1265 // Meta+Ctrl++ ( "Meta+", "Ctrl+", "+" ) -

1266 // Super+Shift+A ( "Super+", "Shift+" ) -

1267 // 4+3+2=1 ( "4+", "3+" ) -

1268 // In other words, everything we try to handle HAS to be a modifier -

1269 // except for a single '+' at the end of the string. -

1270 -

1271 // Only '+' can have length 1. -

1272

if (sub.length() == 1) {

evaluated: sub.length() == 1

TRUE	FALSE
yes Evaluation Count:26	yes Evaluation Count:243

26-243

1273 // Make sure we only encounter a single '+' at the end of the accel -

1274

if (accel.lastIndexOf(QLatin1Char('+')) != accel.length()-1)

evaluated: accel.lastIndexOf(QLatin1Char('+')) != accel.length()-1

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:22

4-22

1275

return Qt::Key_unknown;

executed: return Qt::Key_unknown;

Execution Count:4

1276

bool validModifier = false;

executed: }

Execution Count:22

1277 // Identify the modifier -

1278

executed (the execution status of this line is deduced): bool validModifier = false;

1279

for (int j = 0; j < modifs.size(); ++j) {

evaluated: j < modifs.size()

TRUE	FALSE
yes Evaluation Count:569	yes Evaluation Count:12

12-569

1280

const QModifKeyName &mkf = modifs.at(j);

executed (the execution status of this line is deduced): const QModifKeyName &mkf = modifs.at(j);

1281

if (sub == mkf.name) {

evaluated: sub == mkf.name

TRUE	FALSE
yes Evaluation Count:231	yes Evaluation Count:338

231-338

1282

ret |= mkf.qt_key;

executed (the execution status of this line is deduced): ret |= mkf.qt_key;

1283

validModifier = true;

executed (the execution status of this line is deduced): validModifier = true;

1284

break; // Shortcut, since if we find an other it would/should just be a dup

executed: break;

Execution Count:231

231

1285 } -

1286

executed: }

Execution Count:338

338

1287 -

1288

if (!validModifier)

evaluated: !validModifier

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:231

12-231

1289

return Qt::Key_unknown;

executed: return Qt::Key_unknown;

Execution Count:12

1290

executed: }

Execution Count:231

231

1291

lastI = i + 1;

executed (the execution status of this line is deduced): lastI = i + 1;

1292

int p = accel.lastIndexOf(QLatin1Char('+'), str.length() - 2); // -2 so that Ctrl++ works

executed: }

Execution Count:253

253

1293 #endif -

1294 -

1295

executed (the execution status of this line is deduced): int p = accel.lastIndexOf(QLatin1Char('+'), str.length() - 2);

1296

if(p > 0)

evaluated: p > 0

TRUE	FALSE
yes Evaluation Count:215	yes Evaluation Count:458

215-458

1297

accel = accel.mid(p + 1);

executed: accel = accel.mid(p + 1);

Execution Count:215

215

1298 -

1299

int fnum = 0;

executed (the execution status of this line is deduced): int fnum = 0;

1300

if (accel.length() == 1) {

evaluated: accel.length() == 1

TRUE	FALSE
yes Evaluation Count:206	yes Evaluation Count:467

206-467

1301 #if defined(Q_OS_MAC) && !defined(Q_OS_IOS) -

1302 int qtKey = qtkeyForMacSymbol(accel[0]); -

1303 if (qtKey != -1) { -

1304 ret |= qtKey; -

1305 } else -

1306 #endif -

1307 { -

1308

ret |= accel[0].toUpper().unicode();

executed (the execution status of this line is deduced): ret |= accel[0].toUpper().unicode();

1309 } -

1310

} else if (accel[0] == QLatin1Char('f') && (fnum = accel.mid(1).toInt()) && (fnum >= 1) && (fnum <= 35)) {

executed: }

Execution Count:206

evaluated: accel[0] == QLatin1Char('f')

TRUE	FALSE
yes Evaluation Count:13	yes Evaluation Count:454

partially evaluated: (fnum = accel.mid(1).toInt())

TRUE	FALSE
yes Evaluation Count:13	no Evaluation Count:0

partially evaluated: (fnum >= 1)

TRUE	FALSE
yes Evaluation Count:13	no Evaluation Count:0

partially evaluated: (fnum <= 35)

TRUE	FALSE
yes Evaluation Count:13	no Evaluation Count:0

0-454

1311

ret |= Qt::Key_F1 + fnum - 1;

executed (the execution status of this line is deduced): ret |= Qt::Key_F1 + fnum - 1;

1312

for (int tran = 0; tran < 2; ++tran) {

executed: }

Execution Count:13

1313 // For NativeText, check the traslation table first, -

1314 // if we don't find anything then try it out with just the untranlated stuff. -

1315 // PortableText will only try the untranlated table. -

1316

bool found = false;

executed (the execution status of this line is deduced): bool found = false;

1317

evaluated: tran < 2

TRUE	FALSE
yes Evaluation Count:465	yes Evaluation Count:11

11-465

1318

if (!nativeText)

evaluated: !nativeText

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:459

6-459

1319

++tran;

executed: ++tran;

Execution Count:6

1320

for (int i = 0; keyname[i].name; ++i) {

evaluated: keyname[i].name

TRUE	FALSE
yes Evaluation Count:74317	yes Evaluation Count:22

22-74317

1321

QString keyName(tran == 0

executed (the execution status of this line is deduced): QString keyName(tran == 0

1322

? QCoreApplication::translate("QShortcut", keyname[i].name)

executed (the execution status of this line is deduced): ? QCoreApplication::translate("QShortcut", keyname[i].name)

1323

: QString::fromLatin1(keyname[i].name));

executed (the execution status of this line is deduced): : QString::fromLatin1(keyname[i].name));

1324

if (accel == keyName.toLower()) {

evaluated: accel == keyName.toLower()

TRUE	FALSE
yes Evaluation Count:443	yes Evaluation Count:73874

443-73874

1325

ret |= keyname[i].key;

executed (the execution status of this line is deduced): ret |= keyname[i].key;

1326

found = true;

executed (the execution status of this line is deduced): found = true;

1327

executed: break;

Execution Count:443

443

1328 } -

1329

executed: }

Execution Count:73874

73874

1330

if (found)

evaluated: found

TRUE	FALSE
yes Evaluation Count:443	yes Evaluation Count:22

22-443

1331

executed: break;

Execution Count:443

443

1332

executed: }

Execution Count:22

1333 // We couldn't translate the key. -

1334

if (!found)

evaluated: !found

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:443

11-443

1335

return Qt::Key_unknown;

executed: return Qt::Key_unknown;

Execution Count:11

1336

executed: }

Execution Count:443

443

1337

int keyboardScheme = QPlatformTheme::WindowsKeyboardScheme;

executed: return ret;

Execution Count:662

662

1338 } -

1339 -

1340 unsigned QKeySequencePrivate::currentKeyPlatforms() -

1341 { -

1342

executed (the execution status of this line is deduced): int keyboardScheme = QPlatformTheme::WindowsKeyboardScheme;

1343

if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme())

partially evaluated: const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()

TRUE	FALSE
yes Evaluation Count:130133	no Evaluation Count:0

0-130133

1344

keyboardScheme = theme->themeHint(QPlatformTheme::KeyboardScheme).toInt();

executed: keyboardScheme = theme->themeHint(QPlatformTheme::KeyboardScheme).toInt();

Execution Count:130133

130133

1345

unsigned result = 1u << keyboardScheme;

executed (the execution status of this line is deduced): unsigned result = 1u << keyboardScheme;

1346

if (keyboardScheme == QPlatformTheme::KdeKeyboardScheme

partially evaluated: keyboardScheme == QPlatformTheme::KdeKeyboardScheme

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:130133

0-130133

1347

|| keyboardScheme == QPlatformTheme::GnomeKeyboardScheme

partially evaluated: keyboardScheme == QPlatformTheme::GnomeKeyboardScheme

TRUE	FALSE
yes Evaluation Count:130133	no Evaluation Count:0

0-130133

1348

|| keyboardScheme == QPlatformTheme::CdeKeyboardScheme)

never evaluated: keyboardScheme == QPlatformTheme::CdeKeyboardScheme

1349

result |= KB_X11;

executed: result |= KB_X11;

Execution Count:130133

130133

1350

return result;

executed: return result;

Execution Count:130133

130133

1351 } -

1352 -

1353 /*! -

1354 Creates a shortcut string for \a key. For example, -

1355 Qt::CTRL+Qt::Key_O gives "Ctrl+O". The strings, "Ctrl", "Shift", etc. are -

1356 translated (using QObject::tr()) in the "QShortcut" context. -

1357 */ -

1358 QString QKeySequence::encodeString(int key) -

1359 { -

1360

return QKeySequencePrivate::encodeString(key, NativeText);

never executed: return QKeySequencePrivate::encodeString(key, NativeText);

1361 } -

1362 -

1363 static inline void addKey(QString &str, const QString &theKey, QKeySequence::SequenceFormat format) -

1364 { -

1365

if (!str.isEmpty())

evaluated: !str.isEmpty()

TRUE	FALSE
yes Evaluation Count:317	yes Evaluation Count:357

317-357

1366

str += (format == QKeySequence::NativeText) ? QCoreApplication::translate("QShortcut", "+")

executed: str += (format == QKeySequence::NativeText) ? QCoreApplication::translate("QShortcut", "+") : QString::fromLatin1("+");

Execution Count:317

evaluated: (format == QKeySequence::NativeText)

TRUE	FALSE
yes Evaluation Count:257	yes Evaluation Count:60

60-317

1367

: QString::fromLatin1("+");

executed: str += (format == QKeySequence::NativeText) ? QCoreApplication::translate("QShortcut", "+") : QString::fromLatin1("+");

Execution Count:317

317

1368

str += theKey;

executed (the execution status of this line is deduced): str += theKey;

1369

bool nativeText = (format == QKeySequence::NativeText);

executed: }

Execution Count:674

674

1370 -

1371 QString QKeySequencePrivate::encodeString(int key, QKeySequence::SequenceFormat format) -

1372 { -

1373

executed (the execution status of this line is deduced): bool nativeText = (format == QKeySequence::NativeText);

1374

QString s;

executed (the execution status of this line is deduced): QString s;

1375 -

1376 // Handle -1 (Invalid Key) and Qt::Key_unknown gracefully -

1377

if (key == -1 || key == Qt::Key_unknown)

evaluated: key == -1

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:398

evaluated: key == Qt::Key_unknown

TRUE	FALSE
yes Evaluation Count:29	yes Evaluation Count:369

1-398

1378

if ((key & Qt::META) == Qt::META)

executed: return s;

Execution Count:30

1379 -

1380 #if defined(Q_OS_MAC) && !defined(Q_OS_IOS) -

1381 if (nativeText) { -

1382 // On Mac OS X the order (by default) is Meta, Alt, Shift, Control. -

1383 // If the AA_MacDontSwapCtrlAndMeta is enabled, then the order -

1384 // is Ctrl, Alt, Shift, Meta. The macSymbolForQtKey does this swap -

1385 // for us, which means that we have to adjust our order here. -

1386 // The upshot is a lot more infrastructure to keep the number of -

1387 // if tests down and the code relatively clean. -

1388 static const int ModifierOrder[] = { Qt::META, Qt::ALT, Qt::SHIFT, Qt::CTRL, 0 }; -

1389 static const int QtKeyOrder[] = { Qt::Key_Meta, Qt::Key_Alt, Qt::Key_Shift, Qt::Key_Control, 0 }; -

1390 static const int DontSwapModifierOrder[] = { Qt::CTRL, Qt::ALT, Qt::SHIFT, Qt::META, 0 }; -

1391 static const int DontSwapQtKeyOrder[] = { Qt::Key_Control, Qt::Key_Alt, Qt::Key_Shift, Qt::Key_Meta, 0 }; -

1392 const int *modifierOrder; -

1393 const int *qtkeyOrder; -

1394 if (qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta)) { -

1395 modifierOrder = DontSwapModifierOrder; -

1396 qtkeyOrder = DontSwapQtKeyOrder; -

1397 } else { -

1398 modifierOrder = ModifierOrder; -

1399 qtkeyOrder = QtKeyOrder; -

1400 } -

1401 -

1402 for (int i = 0; modifierOrder[i] != 0; ++i) { -

1403 if (key & modifierOrder[i]) -

1404 s += qt_macSymbolForQtKey(qtkeyOrder[i]); -

1405 } -

1406 } else -

1407 #endif -

1408 { -

1409 // On other systems the order is Meta, Control, Alt, Shift -

1410

evaluated: (key & Qt::META) == Qt::META

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:357

12-357

1411

s = nativeText ? QCoreApplication::translate("QShortcut", "Meta") : QString::fromLatin1("Meta");

executed: s = nativeText ? QCoreApplication::translate("QShortcut", "Meta") : QString::fromLatin1("Meta");

Execution Count:12

evaluated: nativeText

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:6

6-12

1412

if ((key & Qt::CTRL) == Qt::CTRL)

evaluated: (key & Qt::CTRL) == Qt::CTRL

TRUE	FALSE
yes Evaluation Count:246	yes Evaluation Count:123

123-246

1413

addKey(s, nativeText ? QCoreApplication::translate("QShortcut", "Ctrl") : QString::fromLatin1("Ctrl"), format);

executed: addKey(s, nativeText ? QCoreApplication::translate("QShortcut", "Ctrl") : QString::fromLatin1("Ctrl"), format);

Execution Count:246

246

1414

if ((key & Qt::ALT) == Qt::ALT)

evaluated: (key & Qt::ALT) == Qt::ALT

TRUE	FALSE
yes Evaluation Count:38	yes Evaluation Count:331

38-331

1415

addKey(s, nativeText ? QCoreApplication::translate("QShortcut", "Alt") : QString::fromLatin1("Alt"), format);

executed: addKey(s, nativeText ? QCoreApplication::translate("QShortcut", "Alt") : QString::fromLatin1("Alt"), format);

Execution Count:38

1416

if ((key & Qt::SHIFT) == Qt::SHIFT)

evaluated: (key & Qt::SHIFT) == Qt::SHIFT

TRUE	FALSE
yes Evaluation Count:21	yes Evaluation Count:348

21-348

1417

addKey(s, nativeText ? QCoreApplication::translate("QShortcut", "Shift") : QString::fromLatin1("Shift"), format);

executed: addKey(s, nativeText ? QCoreApplication::translate("QShortcut", "Shift") : QString::fromLatin1("Shift"), format);

Execution Count:21

1418 } -

1419 -

1420 -

1421

key &= ~(Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier);

executed (the execution status of this line is deduced): key &= ~(Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier);

1422

QString p;

executed (the execution status of this line is deduced): QString p;

1423 -

1424

if (key && key < Qt::Key_Escape && key != Qt::Key_Space) {

evaluated: key

TRUE	FALSE
yes Evaluation Count:358	yes Evaluation Count:11

evaluated: key < Qt::Key_Escape

TRUE	FALSE
yes Evaluation Count:284	yes Evaluation Count:74

partially evaluated: key != Qt::Key_Space

TRUE	FALSE
yes Evaluation Count:284	no Evaluation Count:0

0-358

1425

if (!QChar::requiresSurrogates(key)) {

partially evaluated: !QChar::requiresSurrogates(key)

TRUE	FALSE
yes Evaluation Count:284	no Evaluation Count:0

0-284

1426

p = QChar(ushort(key)).toUpper();

executed (the execution status of this line is deduced): p = QChar(ushort(key)).toUpper();

1427

p += QChar(QChar::highSurrogate(key));

executed: }

Execution Count:284

284

1428

never executed (the execution status of this line is deduced): p += QChar(QChar::highSurrogate(key));

1429

p += QChar(QChar::lowSurrogate(key));

never executed (the execution status of this line is deduced): p += QChar(QChar::lowSurrogate(key));

1430

} else if (key >= Qt::Key_F1 && key <= Qt::Key_F35) {

never executed: }

1431

evaluated: key >= Qt::Key_F1

TRUE	FALSE
yes Evaluation Count:38	yes Evaluation Count:47

evaluated: key <= Qt::Key_F35

TRUE	FALSE
yes Evaluation Count:8	yes Evaluation Count:30

8-47

1432

p = nativeText ? QCoreApplication::translate("QShortcut", "F%1").arg(key - Qt::Key_F1 + 1)

evaluated: nativeText

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:2

2-6

1433

: QString::fromLatin1("F%1").arg(key - Qt::Key_F1 + 1);

executed (the execution status of this line is deduced): : QString::fromLatin1("F%1").arg(key - Qt::Key_F1 + 1);

1434

} else if (key) {

executed: }

Execution Count:8

evaluated: key

TRUE	FALSE
yes Evaluation Count:66	yes Evaluation Count:11

8-66

1435

int i=0;

executed (the execution status of this line is deduced): int i=0;

1436 #if defined(Q_OS_MAC) && !defined(Q_OS_IOS) -

1437 if (nativeText) { -

1438 QChar ch = qt_macSymbolForQtKey(key); -

1439 if (!ch.isNull()) -

1440 p = ch; -

1441 else -

1442 goto NonSymbol; -

1443 } else -

1444 #endif -

1445 { -

1446 #if defined(Q_OS_MAC) && !defined(Q_OS_IOS) -

1447 NonSymbol: -

1448 #endif -

1449

while (keyname[i].name) {

partially evaluated: keyname[i].name

TRUE	FALSE
yes Evaluation Count:6342	no Evaluation Count:0

0-6342

1450

if (key == keyname[i].key) {

evaluated: key == keyname[i].key

TRUE	FALSE
yes Evaluation Count:66	yes Evaluation Count:6276

66-6276

1451

p = nativeText ? QCoreApplication::translate("QShortcut", keyname[i].name)

evaluated: nativeText

TRUE	FALSE
yes Evaluation Count:19	yes Evaluation Count:47

19-47

1452

: QString::fromLatin1(keyname[i].name);

executed (the execution status of this line is deduced): : QString::fromLatin1(keyname[i].name);

1453

executed: break;

Execution Count:66

1454 } -

1455

++i;

executed (the execution status of this line is deduced): ++i;

1456

if (!QChar::requiresSurrogates(key)) {

executed: }

Execution Count:6276

6276

1457 // If we can't find the actual translatable keyname, -

1458 // fall back on the unicode representation of it... -

1459 // Or else characters like Qt::Key_aring may not get displayed -

1460 // (Really depends on you locale) -

1461

if (!keyname[i].name) {

partially evaluated: !keyname[i].name

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:66

0-66

1462

never evaluated: !QChar::requiresSurrogates(key)

1463

p = QChar(ushort(key)).toUpper();

never executed (the execution status of this line is deduced): p = QChar(ushort(key)).toUpper();

1464

p += QChar(QChar::highSurrogate(key));

never executed: }

1465

never executed (the execution status of this line is deduced): p += QChar(QChar::highSurrogate(key));

1466

p += QChar(QChar::lowSurrogate(key));

never executed (the execution status of this line is deduced): p += QChar(QChar::lowSurrogate(key));

1467

never executed: }

1468 } -

1469 } -

1470

executed: }

Execution Count:66

1471 -

1472 #if defined(Q_OS_MAC) && !defined(Q_OS_IOS) -

1473 if (nativeText) -

1474 s += p; -

1475 else -

1476 #endif -

1477

addKey(s, p, format);

executed (the execution status of this line is deduced): addKey(s, p, format);

1478

SequenceMatch match = (userN == seqN ? ExactMatch : PartialMatch);

executed: return s;

Execution Count:369

369

1479 } -

1480 /*! -

1481 Matches the sequence with \a seq. Returns ExactMatch if -

1482 successful, PartialMatch if \a seq matches incompletely, -

1483 and NoMatch if the sequences have nothing in common. -

1484 Returns NoMatch if \a seq is shorter. -

1485 */ -

1486 QKeySequence::SequenceMatch QKeySequence::matches(const QKeySequence &seq) const -

1487 { -

1488

uint userN = count(),

never executed (the execution status of this line is deduced): uint userN = count(),

1489

seqN = seq.count();

never executed (the execution status of this line is deduced): seqN = seq.count();

1490 -

1491

if (userN > seqN)

never evaluated: userN > seqN

1492

return NoMatch;

never executed: return NoMatch;

1493 -

1494 // If equal in length, we have a potential ExactMatch sequence, -

1495 // else we already know it can only be partial. -

1496

never evaluated: userN == seqN

1497 -

1498

for (uint i = 0; i < userN; ++i) {

never evaluated: i < userN

1499

int userKey = (*this)[i],

never executed (the execution status of this line is deduced): int userKey = (*this)[i],

1500

sequenceKey = seq[i];

never executed (the execution status of this line is deduced): sequenceKey = seq[i];

1501

if (userKey != sequenceKey)

never evaluated: userKey != sequenceKey

1502

return NoMatch;

never executed: return NoMatch;

never executed: }

never executed: return match;

1505 } -

1506 -

1507 -

1508 /*! \fn QKeySequence::operator QString() const -

1509 -

1510 \obsolete -

1511 -

1512 Use toString() instead. -

1513 -

1514 Returns the key sequence as a QString. This is equivalent to -

1515 calling toString(QKeySequence::NativeText). Note that the -

1516 result is not platform independent. -

1517 */ -

1518 -

1519 /*! -

1520 Returns the key sequence as a QVariant -

1521 */ -

1522 QKeySequence::operator QVariant() const -

1523 { -

1524

return QVariant(QVariant::KeySequence, this);

executed: return QVariant(QVariant::KeySequence, this);

Execution Count:1

1525 } -

1526 -

1527 /*! \fn QKeySequence::operator int () const -

1528 -

1529 \obsolete -

1530 For backward compatibility: returns the first keycode -

1531 as integer. If the key sequence is empty, 0 is returned. -

1532 */ -

1533 -

1534 /*! -

1535 Returns a reference to the element at position \a index in the key -

1536 sequence. This can only be used to read an element. -

1537 */ -

1538 int QKeySequence::operator[](uint index) const -

1539 { -

1540

Q_ASSERT_X(index < 4, "QKeySequence::operator[]", "index out of range");

executed (the execution status of this line is deduced): qt_noop();

1541

return d->key[index];

executed: return d->key[index];

Execution Count:833

833

1542 } -

1543 -

1544 -

1545 /*! -

1546 Assignment operator. Assigns the \a other key sequence to this -

1547 object. -

1548 */ -

1549 QKeySequence &QKeySequence::operator=(const QKeySequence &other) -

1550 { -

1551

qAtomicAssign(d, other.d);

executed (the execution status of this line is deduced): qAtomicAssign(d, other.d);

1552

return *this;

executed: return *this;

Execution Count:3908

3908

1553 } -

1554 -

1555 /*! -

1556 \fn void QKeySequence::swap(QKeySequence &other) -

1557 \since 4.8 -

1558 -

1559 Swaps key sequence \a other with this key sequence. This operation is very -

1560 fast and never fails. -

1561 */ -

1562 -

1563 /*! -

1564 \fn bool QKeySequence::operator!=(const QKeySequence &other) const -

1565 -

1566 Returns true if this key sequence is not equal to the \a other -

1567 key sequence; otherwise returns false. -

1568 */ -

1569 -

1570 -

1571 /*! -

1572 Returns true if this key sequence is equal to the \a other -

1573 key sequence; otherwise returns false. -

1574 */ -

1575 bool QKeySequence::operator==(const QKeySequence &other) const -

1576 { -

1577

return (d->key[0] == other.d->key[0] &&

executed:

return (d->key[0] == other.d->key[0] && d->key[1] == other.d->key[1] && d->key[2] == other.d->key[2] && d->key[3] == other.d->key[3]);

Execution Count:2147

2147

1578

d->key[1] == other.d->key[1] &&

executed:

return (d->key[0] == other.d->key[0] && d->key[1] == other.d->key[1] && d->key[2] == other.d->key[2] && d->key[3] == other.d->key[3]);

Execution Count:2147

2147

1579

d->key[2] == other.d->key[2] &&

executed:

return (d->key[0] == other.d->key[0] && d->key[1] == other.d->key[1] && d->key[2] == other.d->key[2] && d->key[3] == other.d->key[3]);

Execution Count:2147

2147

1580

d->key[3] == other.d->key[3]);

executed:

return (d->key[0] == other.d->key[0] && d->key[1] == other.d->key[1] && d->key[2] == other.d->key[2] && d->key[3] == other.d->key[3]);

Execution Count:2147

2147

1581 } -

1582 -

1583 -

1584 /*! -

1585 Provides an arbitrary comparison of this key sequence and -

1586 \a other key sequence. All that is guaranteed is that the -

1587 operator returns false if both key sequences are equal and -

1588 that (ks1 \< ks2) == !( ks2 \< ks1) if the key sequences -

1589 are not equal. -

1590 -

1591 This function is useful in some circumstances, for example -

1592 if you want to use QKeySequence objects as keys in a QMap. -

1593 -

1594 \sa operator==(), operator!=(), operator>(), operator<=(), operator>=() -

1595 */ -

1596 bool QKeySequence::operator< (const QKeySequence &other) const -

1597 { -

1598

for (int i = 0; i < 4; ++i)

evaluated: i < 4

TRUE	FALSE
yes Evaluation Count:7574	yes Evaluation Count:678

678-7574

1599

if (d->key[i] != other.d->key[i])

evaluated: d->key[i] != other.d->key[i]

TRUE	FALSE
yes Evaluation Count:4852	yes Evaluation Count:2722

2722-4852

1600

return d->key[i] < other.d->key[i];

executed: return d->key[i] < other.d->key[i];

Execution Count:4852

4852

1601

return false;

executed: return false;

Execution Count:678

678

1602 } -

1603 -

1604 /*! -

1605 \fn bool QKeySequence::operator> (const QKeySequence &other) const -

1606 -

1607 Returns true if this key sequence is larger than the \a other key -

1608 sequence; otherwise returns false. -

1609 -

1610 \sa operator==(), operator!=(), operator<(), operator<=(), operator>=() -

1611 */ -

1612 -

1613 /*! -

1614 \fn bool QKeySequence::operator<= (const QKeySequence &other) const -

1615 -

1616 Returns true if this key sequence is smaller or equal to the -

1617 \a other key sequence; otherwise returns false. -

1618 -

1619 \sa operator==(), operator!=(), operator<(), operator>(), operator>=() -

1620 */ -

1621 -

1622 /*! -

1623 \fn bool QKeySequence::operator>= (const QKeySequence &other) const -

1624 -

1625 Returns true if this key sequence is larger or equal to the -

1626 \a other key sequence; otherwise returns false. -

1627 -

1628 \sa operator==(), operator!=(), operator<(), operator>(), operator<=() -

1629 */ -

1630 -

1631 /*! -

1632 \internal -

1633 */ -

1634 bool QKeySequence::isDetached() const -

1635 { -

1636

return d->ref.load() == 1;

never executed: return d->ref.load() == 1;

1637 } -

1638 -

1639 /*! -

1640 \since 4.1 -

1641 -

1642 Return a string representation of the key sequence, -

1643 based on \a format. -

1644 -

1645 For example, the value Qt::CTRL+Qt::Key_O results in "Ctrl+O". -

1646 If the key sequence has multiple key codes, each is separated -

1647 by commas in the string returned, such as "Alt+X, Ctrl+Y, Z". -

1648 The strings, "Ctrl", "Shift", etc. are translated using -

1649 QObject::tr() in the "QShortcut" context. -

1650 -

1651 If the key sequence has no keys, an empty string is returned. -

1652 -

1653 On Mac OS X, the string returned resembles the sequence that is -

1654 shown in the menu bar. -

1655 -

1656 \sa fromString() -

1657 */ -

1658 QString QKeySequence::toString(SequenceFormat format) const -

1659 { -

1660

QString finalString;

executed (the execution status of this line is deduced): QString finalString;

1661 // A standard string, with no translation or anything like that. In some ways it will -

1662 // look like our latin case on Windows and X11 -

1663

int end = count();

executed (the execution status of this line is deduced): int end = count();

1664

for (int i = 0; i < end; ++i) {

evaluated: i < end

TRUE	FALSE
yes Evaluation Count:399	yes Evaluation Count:385

385-399

1665

finalString += d->encodeString(d->key[i], format);

executed (the execution status of this line is deduced): finalString += d->encodeString(d->key[i], format);

1666

finalString += QLatin1String(", ");

executed (the execution status of this line is deduced): finalString += QLatin1String(", ");

1667

finalString.truncate(finalString.length() - 2);

executed: }

Execution Count:399

399

1668

executed (the execution status of this line is deduced): finalString.truncate(finalString.length() - 2);

1669

return finalString;

executed: return finalString;

Execution Count:385

385

1670 } -

1671 -

1672 /*! -

1673 \since 4.1 -

1674 -

1675 Return a QKeySequence from the string \a str based on \a format. -

1676 -

1677 \sa toString() -

1678 */ -

1679 QKeySequence QKeySequence::fromString(const QString &str, SequenceFormat format) -

1680 { -

1681

return QKeySequence(str, format);

executed: return QKeySequence(str, format);

Execution Count:35

1682 } -

1683 -

1684 /***************************************************************************** -

1685 QKeySequence stream functions -

1686 *****************************************************************************/ -

1687 #if !defined(QT_NO_DATASTREAM) -

1688 /*! -

1689 \fn QDataStream &operator<<(QDataStream &stream, const QKeySequence &sequence) -

1690 \relates QKeySequence -

1691 -

1692 Writes the key \a sequence to the \a stream. -

1693 -

1694 \sa{Serializing Qt Data Types}{Format of the QDataStream operators} -

1695 */ -

1696 QDataStream &operator<<(QDataStream &s, const QKeySequence &keysequence) -

1697 { -

1698

QList<quint32> list;

executed (the execution status of this line is deduced): QList<quint32> list;

1699

list << keysequence.d->key[0];

executed (the execution status of this line is deduced): list << keysequence.d->key[0];

1700 -

1701

if (s.version() >= 5 && keysequence.count() > 1) {

evaluated: s.version() >= 5

TRUE	FALSE
yes Evaluation Count:28	yes Evaluation Count:8

evaluated: keysequence.count() > 1

TRUE	FALSE
yes Evaluation Count:9	yes Evaluation Count:19

8-28

1702

list << keysequence.d->key[1];

executed (the execution status of this line is deduced): list << keysequence.d->key[1];

1703

list << keysequence.d->key[2];

executed (the execution status of this line is deduced): list << keysequence.d->key[2];

1704

list << keysequence.d->key[3];

executed (the execution status of this line is deduced): list << keysequence.d->key[3];

1705

executed: }

Execution Count:9

1706

s << list;

executed (the execution status of this line is deduced): s << list;

1707

qAtomicDetach(keysequence.d);

executed: return s;

Execution Count:36

1708 } -

1709 -

1710 -

1711 /*! -

1712 \fn QDataStream &operator>>(QDataStream &stream, QKeySequence &sequence) -

1713 \relates QKeySequence -

1714 -

1715 Reads a key sequence from the \a stream into the key \a sequence. -

1716 -

1717 \sa{Serializing Qt Data Types}{Format of the QDataStream operators} -

1718 */ -

1719 QDataStream &operator>>(QDataStream &s, QKeySequence &keysequence) -

1720 { -

1721

executed (the execution status of this line is deduced): qAtomicDetach(keysequence.d);

1722

QList<quint32> list;

executed (the execution status of this line is deduced): QList<quint32> list;

1723

s >> list;

executed (the execution status of this line is deduced): s >> list;

1724

for (int i = 0; i < 4; ++i)

evaluated: i < 4

TRUE	FALSE
yes Evaluation Count:144	yes Evaluation Count:36

36-144

1725

keysequence.d->key[i] = list.value(i);

executed: keysequence.d->key[i] = list.value(i);

Execution Count:144

144

1726