text/qfontmetrics.cpp

never executed (the execution status of this line is deduced): QStackTextEngine layout(text, QFont(d.data()));

842

never executed (the execution status of this line is deduced): layout.ignoreBidi = true;

843

glyph_metrics_t gm = layout.tightBoundingBox(0, text.length());

never executed (the execution status of this line is deduced): layout.itemize();

844

never executed (the execution status of this line is deduced): glyph_metrics_t gm = layout.tightBoundingBox(0, text.length());

845

return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));

never executed: return QRect(qRound(gm.x), qRound(gm.y), qRound(gm.width), qRound(gm.height));

846 } -

847 -

848 -

849 /*! -

850 \since 4.2 -

851 -

852 If the string \a text is wider than \a width, returns an elided -

853 version of the string (i.e., a string with "..." in it). -

854 Otherwise, returns the original string. -

855 -

856 The \a mode parameter specifies whether the text is elided on the -

857 left (e.g., "...tech"), in the middle (e.g., "Tr...ch"), or on -

858 the right (e.g., "Trol..."). -

859 -

860 The \a width is specified in pixels, not characters. -

861 -

862 The \a flags argument is optional and currently only supports -

863 Qt::TextShowMnemonic as value. -

864 -

865 The elide mark will follow the \l{Qt::LayoutDirection}{layout -

866 direction}; it will be on the right side of the text for -

867 right-to-left layouts, and on the left side for right-to-left -

868 layouts. Note that this behavior is independent of the text -

869 language. -

870 */ -

871 QString QFontMetrics::elidedText(const QString &text, Qt::TextElideMode mode, int width, int flags) const -

872 { -

873

QString _text = text;

executed (the execution status of this line is deduced): QString _text = text;

874

if (!(flags & Qt::TextLongestVariant)) {

partially evaluated: !(flags & Qt::TextLongestVariant)

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

0-3425

875

int posA = 0;

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

876

int posB = _text.indexOf(QLatin1Char('\x9c'));

executed (the execution status of this line is deduced): int posB = _text.indexOf(QLatin1Char('\x9c'));

877

while (posB >= 0) {

evaluated: posB >= 0

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:3421

10-3421

878

QString portion = _text.mid(posA, posB - posA);

executed (the execution status of this line is deduced): QString portion = _text.mid(posA, posB - posA);

879

if (size(flags, portion).width() <= width)

evaluated: size(flags, portion).width() <= width

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

4-6

880

return portion;

executed: return portion;

Execution Count:4

881

posA = posB + 1;

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

882

posB = _text.indexOf(QLatin1Char('\x9c'), posA);

executed (the execution status of this line is deduced): posB = _text.indexOf(QLatin1Char('\x9c'), posA);

883

executed: }

Execution Count:6

884

_text = _text.mid(posA);

executed (the execution status of this line is deduced): _text = _text.mid(posA);

885

QStackTextEngine engine(_text, QFont(d.data()));

executed: }

Execution Count:3421

3421

886

executed (the execution status of this line is deduced): QStackTextEngine engine(_text, QFont(d.data()));

887

return engine.elidedText(mode, width, flags);

executed: return engine.elidedText(mode, width, flags);

Execution Count:3421

3421

888 } -

889 -

890 /*! -

891 Returns the distance from the base line to where an underscore -

892 should be drawn. -

893 -

894 \sa overlinePos(), strikeOutPos(), lineWidth() -

895 */ -

896 int QFontMetrics::underlinePos() const -

897 { -

898

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

899

return qRound(engine->underlinePosition());

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

900

never executed: return qRound(engine->underlinePosition());

901 } -

902 -

903 /*! -

904 Returns the distance from the base line to where an overline -

905 should be drawn. -

906 -

907 \sa underlinePos(), strikeOutPos(), lineWidth() -

908 */ -

909 int QFontMetrics::overlinePos() const -

910 { -

911

return ascent() + 1;

never executed: return ascent() + 1;

912 } -

913 -

914 /*! -

915 Returns the distance from the base line to where the strikeout -

916 line should be drawn. -

917 -

918 \sa underlinePos(), overlinePos(), lineWidth() -

919 */ -

920 int QFontMetrics::strikeOutPos() const -

921 { -

922

int pos = ascent() / 3;

never executed (the execution status of this line is deduced): int pos = ascent() / 3;

923

return pos > 0 ? pos : 1;

never executed: return pos > 0 ? pos : 1;

924 } -

925 -

926 /*! -

927 Returns the width of the underline and strikeout lines, adjusted -

928 for the point size of the font. -

929 -

930 \sa underlinePos(), overlinePos(), strikeOutPos() -

931 */ -

932 int QFontMetrics::lineWidth() const -

933 { -

934

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

935

return qRound(engine->lineThickness());

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

936

executed: return qRound(engine->lineThickness());

Execution Count:3

937 } -

938 -

939 -

940 -

941 -

942 /***************************************************************************** -

943 QFontMetricsF member functions -

944 *****************************************************************************/ -

945 -

946 /*! -

947 \class QFontMetricsF -

948 \reentrant -

949 \inmodule QtGui -

950 -

951 \brief The QFontMetricsF class provides font metrics information. -

952 -

953 \ingroup painting -

954 \ingroup shared -

955 -

956 QFontMetricsF functions calculate the size of characters and -

957 strings for a given font. You can construct a QFontMetricsF object -

958 with an existing QFont to obtain metrics for that font. If the -

959 font is changed later, the font metrics object is \e not updated. -

960 -

961 Once created, the object provides functions to access the -

962 individual metrics of the font, its characters, and for strings -

963 rendered in the font. -

964 -

965 There are several functions that operate on the font: ascent(), -

966 descent(), height(), leading() and lineSpacing() return the basic -

967 size properties of the font. The underlinePos(), overlinePos(), -

968 strikeOutPos() and lineWidth() functions, return the properties of -

969 the line that underlines, overlines or strikes out the -

970 characters. These functions are all fast. -

971 -

972 There are also some functions that operate on the set of glyphs in -

973 the font: minLeftBearing(), minRightBearing() and maxWidth(). -

974 These are by necessity slow, and we recommend avoiding them if -

975 possible. -

976 -

977 For each character, you can get its width(), leftBearing() and -

978 rightBearing() and find out whether it is in the font using -

979 inFont(). You can also treat the character as a string, and use -

980 the string functions on it. -

981 -

982 The string functions include width(), to return the width of a -

983 string in pixels (or points, for a printer), boundingRect(), to -

984 return a rectangle large enough to contain the rendered string, -

985 and size(), to return the size of that rectangle. -

986 -

987 Example: -

988 \snippet code/src_gui_text_qfontmetrics.cpp 1 -

989 -

990 \sa QFont, QFontInfo, QFontDatabase -

991 */ -

992 -

993 /*! -

994 \since 4.2 -

995 -

996 Constructs a font metrics object with floating point precision -

997 from the given \a fontMetrics object. -

998 */ -

999 QFontMetricsF::QFontMetricsF(const QFontMetrics &fontMetrics) -

1000 : d(fontMetrics.d.data()) -

1001 { -

1002

executed: }

Execution Count:995

995

1003 -

1004 /*! -

1005 \since 4.2 -

1006 -

1007 Assigns \a other to this object. -

1008 */ -

1009 QFontMetricsF &QFontMetricsF::operator=(const QFontMetrics &other) -

1010 { -

1011

d = other.d.data();

never executed (the execution status of this line is deduced): d = other.d.data();

1012

return *this;

never executed: return *this;

1013 } -

1014 -

1015 /*! -

1016 \fn void QFontMetricsF::swap(QFontMetricsF &other) -

1017 \since 5.0 -

1018 -

1019 Swaps this font metrics instance with \a other. This function is -

1020 very fast and never fails. -

1021 */ -

1022 -

1023 -

1024 -

1025 /*! -

1026 Constructs a font metrics object for \a font. -

1027 -

1028 The font metrics will be compatible with the paintdevice used to -

1029 create \a font. -

1030 -

1031 The font metrics object holds the information for the font that is -

1032 passed in the constructor at the time it is created, and is not -

1033 updated if the font's attributes are changed later. -

1034 -

1035 Use QFontMetricsF(const QFont &, QPaintDevice *) to get the font -

1036 metrics that are compatible with a certain paint device. -

1037 */ -

1038 QFontMetricsF::QFontMetricsF(const QFont &font) -

1039 : d(font.d.data()) -

1040 { -

1041

int dpi = paintdevice ? paintdevice->logicalDpiY() : qt_defaultDpi();

executed: }

Execution Count:35634

35634

1042 -

1043 /*! -

1044 Constructs a font metrics object for \a font and \a paintdevice. -

1045 -

1046 The font metrics will be compatible with the paintdevice passed. -

1047 If the \a paintdevice is 0, the metrics will be screen-compatible, -

1048 ie. the metrics you get if you use the font for drawing text on a -

1049 \l{QWidget}{widgets} or \l{QPixmap}{pixmaps}, -

1050 not on a QPicture or QPrinter. -

1051 -

1052 The font metrics object holds the information for the font that is -

1053 passed in the constructor at the time it is created, and is not -

1054 updated if the font's attributes are changed later. -

1055 */ -

1056 QFontMetricsF::QFontMetricsF(const QFont &font, QPaintDevice *paintdevice) -

1057 { -

1058

partially evaluated: paintdevice

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

0-1

1059

const int screen = 0;

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

1060

if (font.d->dpi != dpi || font.d->screen != screen ) {

partially evaluated: font.d->dpi != dpi

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

never evaluated: font.d->screen != screen

0-1

1061

d = new QFontPrivate(*font.d);

executed (the execution status of this line is deduced): d = new QFontPrivate(*font.d);

1062

d->dpi = dpi;

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

1063

d->screen = screen;

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

1064

} else {

executed: }

Execution Count:1

1065

d = font.d.data();

never executed (the execution status of this line is deduced): d = font.d.data();

1066

never executed: }

1067 -

1068 } -

1069 -

1070 /*! -

1071 Constructs a copy of \a fm. -

1072 */ -

1073 QFontMetricsF::QFontMetricsF(const QFontMetricsF &fm) -

1074 : d(fm.d.data()) -

1075 { -

1076

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed: }

1077 -

1078 /*! -

1079 Destroys the font metrics object and frees all allocated -

1080 resources. -

1081 */ -

1082 QFontMetricsF::~QFontMetricsF() -

1083 { -

1084 } -

1085 -

1086 /*! -

1087 Assigns the font metrics \a fm to this font metrics object. -

1088 */ -

1089 QFontMetricsF &QFontMetricsF::operator=(const QFontMetricsF &fm) -

1090 { -

1091

d = fm.d.data();

never executed (the execution status of this line is deduced): d = fm.d.data();

1092

return *this;

never executed: return *this;

1093 } -

1094 -

1095 /*! -

1096 Returns true if the font metrics are equal to the \a other font -

1097 metrics; otherwise returns false. -

1098 -

1099 Two font metrics are considered equal if they were constructed from the -

1100 same QFont and the paint devices they were constructed for are -

1101 considered to be compatible. -

1102 */ -

1103 bool QFontMetricsF::operator ==(const QFontMetricsF &other) const -

1104 { -

1105

return d == other.d;

never executed: return d == other.d;

1106 } -

1107 -

1108 /*! -

1109 \fn bool QFontMetricsF::operator !=(const QFontMetricsF &other) const -

1110 \overload -

1111 -

1112 Returns true if the font metrics are not equal to the \a other font -

1113 metrics; otherwise returns false. -

1114 -

1115 \sa operator==() -

1116 */ -

1117 -

1118 /*! -

1119 Returns the ascent of the font. -

1120 -

1121 The ascent of a font is the distance from the baseline to the -

1122 highest position characters extend to. In practice, some font -

1123 designers break this rule, e.g. when they put more than one accent -

1124 on top of a character, or to accommodate an unusual character in -

1125 an exotic language, so it is possible (though rare) that this -

1126 value will be too small. -

1127 -

1128 \sa descent() -

1129 */ -

1130 qreal QFontMetricsF::ascent() const -

1131 { -

1132

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1133

return engine->ascent().toReal();

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

1134

never executed: return engine->ascent().toReal();

1135 } -

1136 -

1137 -

1138 /*! -

1139 Returns the descent of the font. -

1140 -

1141 The descent is the distance from the base line to the lowest point -

1142 characters extend to. (Note that this is different from X, which -

1143 adds 1 pixel.) In practice, some font designers break this rule, -

1144 e.g. to accommodate an unusual character in an exotic language, so -

1145 it is possible (though rare) that this value will be too small. -

1146 -

1147 \sa ascent() -

1148 */ -

1149 qreal QFontMetricsF::descent() const -

1150 { -

1151

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1152

return engine->descent().toReal();

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

1153

never executed: return engine->descent().toReal();

1154 } -

1155 -

1156 /*! -

1157 Returns the height of the font. -

1158 -

1159 This is always equal to ascent()+descent()+1 (the 1 is for the -

1160 base line). -

1161 -

1162 \sa leading(), lineSpacing() -

1163 */ -

1164 qreal QFontMetricsF::height() const -

1165 { -

1166

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1167

return (engine->ascent() + engine->descent()).toReal();

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

1168 -

1169

executed: return (engine->ascent() + engine->descent()).toReal();

Execution Count:1237

1237

1170 } -

1171 -

1172 /*! -

1173 Returns the leading of the font. -

1174 -

1175 This is the natural inter-line spacing. -

1176 -

1177 \sa height(), lineSpacing() -

1178 */ -

1179 qreal QFontMetricsF::leading() const -

1180 { -

1181

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1182

return engine->leading().toReal();

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

1183

executed: return engine->leading().toReal();

Execution Count:35389

35389

1184 } -

1185 -

1186 /*! -

1187 Returns the distance from one base line to the next. -

1188 -

1189 This value is always equal to leading()+height(). -

1190 -

1191 \sa height(), leading() -

1192 */ -

1193 qreal QFontMetricsF::lineSpacing() const -

1194 { -

1195

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1196

return (engine->leading() + engine->ascent() + engine->descent()).toReal();

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

1197

never executed: return (engine->leading() + engine->ascent() + engine->descent()).toReal();

1198 } -

1199 -

1200 /*! -

1201 Returns the minimum left bearing of the font. -

1202 -

1203 This is the smallest leftBearing(char) of all characters in the -

1204 font. -

1205 -

1206 Note that this function can be very slow if the font is large. -

1207 -

1208 \sa minRightBearing(), leftBearing() -

1209 */ -

1210 qreal QFontMetricsF::minLeftBearing() const -

1211 { -

1212

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1213

return engine->minLeftBearing();

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

1214

never executed: return engine->minLeftBearing();

1215 } -

1216 -

1217 /*! -

1218 Returns the minimum right bearing of the font. -

1219 -

1220 This is the smallest rightBearing(char) of all characters in the -

1221 font. -

1222 -

1223 Note that this function can be very slow if the font is large. -

1224 -

1225 \sa minLeftBearing(), rightBearing() -

1226 */ -

1227 qreal QFontMetricsF::minRightBearing() const -

1228 { -

1229

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1230

return engine->minRightBearing();

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

1231

never executed: return engine->minRightBearing();

1232 } -

1233 -

1234 /*! -

1235 Returns the width of the widest character in the font. -

1236 */ -

1237 qreal QFontMetricsF::maxWidth() const -

1238 { -

1239

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1240

return engine->maxCharWidth();

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

1241

never executed: return engine->maxCharWidth();

1242 } -

1243 -

1244 /*! -

1245 Returns the 'x' height of the font. This is often but not always -

1246 the same as the height of the character 'x'. -

1247 */ -

1248 qreal QFontMetricsF::xHeight() const -

1249 { -

1250

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1251

if (d->capital == QFont::SmallCaps)

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

1252

never evaluated: d->capital == QFont::SmallCaps

1253

return d->smallCapsFontPrivate()->engineForScript(QUnicodeTables::Common)->ascent().toReal();

never executed: return d->smallCapsFontPrivate()->engineForScript(QUnicodeTables::Common)->ascent().toReal();

1254

return engine->xHeight().toReal();

never executed: return engine->xHeight().toReal();

1255 } -

1256 -

1257 /*! -

1258 \since 4.2 -

1259 -

1260 Returns the average width of glyphs in the font. -

1261 */ -

1262 qreal QFontMetricsF::averageCharWidth() const -

1263 { -

1264

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1265

return engine->averageCharWidth().toReal();

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

1266

executed: return engine->averageCharWidth().toReal();

Execution Count:1

1267 } -

1268 -

1269 /*! -

1270 Returns true if character \a ch is a valid character in the font; -

1271 otherwise returns false. -

1272 */ -

1273 bool QFontMetricsF::inFont(QChar ch) const -

1274 { -

1275

QFontEngine *engine = d->engineForScript(script);

never executed (the execution status of this line is deduced): const int script = QUnicodeTables::script(ch);

1276

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(script);

1277

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

1278

return engine->canRender(&ch, 1);

never evaluated: engine->type() == QFontEngine::Box

1279

return false;

never executed: return false;

1280

never executed: return engine->canRender(&ch, 1);

1281 } -

1282 -

1283 /*! -

1284 \fn bool QFontMetricsF::inFontUcs4(uint ch) const -

1285 -

1286 Returns true if the character given by \a ch, encoded in UCS-4/UTF-32, -

1287 is a valid character in the font; otherwise returns false. -

1288 */ -

1289 bool QFontMetricsF::inFontUcs4(uint ucs4) const -

1290 { -

1291

const int script = QUnicodeTables::script(ucs4);

executed (the execution status of this line is deduced): const int script = QUnicodeTables::script(ucs4);

1292

QFontEngine *engine = d->engineForScript(script);

executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(script);

1293

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

1294

return engine->canRender(ucs4);

partially evaluated: engine->type() == QFontEngine::Box

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

0-1

1295

return false;

never executed: return false;

1296

executed: return engine->canRender(ucs4);

Execution Count:1

1297 } -

1298 -

1299 /*! -

1300 Returns the left bearing of character \a ch in the font. -

1301 -

1302 The left bearing is the right-ward distance of the left-most pixel -

1303 of the character from the logical origin of the character. This -

1304 value is negative if the pixels of the character extend to the -

1305 left of the logical origin. -

1306 -

1307 See width(QChar) for a graphical description of this metric. -

1308 -

1309 \sa rightBearing(), minLeftBearing(), width() -

1310 */ -

1311 qreal QFontMetricsF::leftBearing(QChar ch) const -

1312 { -

1313

never executed (the execution status of this line is deduced): const int script = QUnicodeTables::script(ch);

1314

if (d->capital == QFont::SmallCaps && ch.isLower())

never executed (the execution status of this line is deduced): QFontEngine *engine;

1315

never evaluated: d->capital == QFont::SmallCaps

never evaluated: ch.isLower()

1316

engine = d->smallCapsFontPrivate()->engineForScript(script);

never executed: engine = d->smallCapsFontPrivate()->engineForScript(script);

1317 else -

1318

never executed: engine = d->engineForScript(script);

1319

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

1320

never evaluated: engine->type() == QFontEngine::Box

1321

return 0;

never executed: return 0;

1322 -

1323

QGlyphLayoutArray<10> glyphs;

never executed (the execution status of this line is deduced): d->alterCharForCapitalization(ch);

1324 -

1325

never executed (the execution status of this line is deduced): QGlyphLayoutArray<10> glyphs;

1326

int nglyphs = 9;

never executed (the execution status of this line is deduced): int nglyphs = 9;

1327

engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, QFontEngine::GlyphIndicesOnly);

never executed (the execution status of this line is deduced): engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, QFontEngine::GlyphIndicesOnly);

1328 // ### can nglyphs != 1 happen at all? Not currently I think -

1329

qreal lb;

never executed (the execution status of this line is deduced): qreal lb;

1330

engine->getGlyphBearings(glyphs.glyphs[0], &lb);

never executed (the execution status of this line is deduced): engine->getGlyphBearings(glyphs.glyphs[0], &lb);

1331

return lb;

never executed: return lb;

1332 } -

1333 -

1334 /*! -

1335 Returns the right bearing of character \a ch in the font. -

1336 -

1337 The right bearing is the left-ward distance of the right-most -

1338 pixel of the character from the logical origin of a subsequent -

1339 character. This value is negative if the pixels of the character -

1340 extend to the right of the width() of the character. -

1341 -

1342 See width() for a graphical description of this metric. -

1343 -

1344 \sa leftBearing(), minRightBearing(), width() -

1345 */ -

1346 qreal QFontMetricsF::rightBearing(QChar ch) const -

1347 { -

1348

never executed (the execution status of this line is deduced): const int script = QUnicodeTables::script(ch);

1349

if (d->capital == QFont::SmallCaps && ch.isLower())

never executed (the execution status of this line is deduced): QFontEngine *engine;

1350

never evaluated: d->capital == QFont::SmallCaps

never evaluated: ch.isLower()

1351

engine = d->smallCapsFontPrivate()->engineForScript(script);

never executed: engine = d->smallCapsFontPrivate()->engineForScript(script);

1352 else -

1353

never executed: engine = d->engineForScript(script);

1354

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

1355

never evaluated: engine->type() == QFontEngine::Box

1356

return 0;

never executed: return 0;

1357 -

1358

QGlyphLayoutArray<10> glyphs;

never executed (the execution status of this line is deduced): d->alterCharForCapitalization(ch);

1359 -

1360

never executed (the execution status of this line is deduced): QGlyphLayoutArray<10> glyphs;

1361

int nglyphs = 9;

never executed (the execution status of this line is deduced): int nglyphs = 9;

1362

engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, QFontEngine::GlyphIndicesOnly);

never executed (the execution status of this line is deduced): engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, QFontEngine::GlyphIndicesOnly);

1363 // ### can nglyphs != 1 happen at all? Not currently I think -

1364

qreal rb;

never executed (the execution status of this line is deduced): qreal rb;

1365

engine->getGlyphBearings(glyphs.glyphs[0], 0, &rb);

never executed (the execution status of this line is deduced): engine->getGlyphBearings(glyphs.glyphs[0], 0, &rb);

1366

return rb;

never executed: return rb;

1367 -

1368 } -

1369 -

1370 /*! -

1371 Returns the width in pixels of the characters in the given \a text. -

1372 -

1373 Note that this value is \e not equal to the width returned by -

1374 boundingRect().width() because boundingRect() returns a rectangle -

1375 describing the pixels this string will cover whereas width() -

1376 returns the distance to where the next string should be drawn. -

1377 -

1378 \sa boundingRect() -

1379 */ -

1380 qreal QFontMetricsF::width(const QString &text) const -

1381 { -

1382

int pos = text.indexOf(QLatin1Char('\x9c'));

executed (the execution status of this line is deduced): int pos = text.indexOf(QLatin1Char('\x9c'));

1383

int len = (pos != -1) ? pos : text.length();

partially evaluated: (pos != -1)

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

0-1

1384 -

1385

executed (the execution status of this line is deduced): QStackTextEngine layout(text, QFont(d.data()));

1386

executed (the execution status of this line is deduced): layout.ignoreBidi = true;

1387

return layout.width(0, len).toReal();

executed (the execution status of this line is deduced): layout.itemize();

1388

executed: return layout.width(0, len).toReal();

Execution Count:1

1389 } -

1390 -

1391 /*! -

1392 \overload -

1393 -

1394 \image bearings.png Bearings -

1395 -

1396 Returns the logical width of character \a ch in pixels. This is a -

1397 distance appropriate for drawing a subsequent character after \a -

1398 ch. -

1399 -

1400 Some of the metrics are described in the image to the right. The -

1401 central dark rectangles cover the logical width() of each -

1402 character. The outer pale rectangles cover the leftBearing() and -

1403 rightBearing() of each character. Notice that the bearings of "f" -

1404 in this particular font are both negative, while the bearings of -

1405 "o" are both positive. -

1406 -

1407 \warning This function will produce incorrect results for Arabic -

1408 characters or non-spacing marks in the middle of a string, as the -

1409 glyph shaping and positioning of marks that happens when -

1410 processing strings cannot be taken into account. When implementing -

1411 an interactive text control, use QTextLayout instead. -

1412 -

1413 \sa boundingRect() -

1414 */ -

1415 qreal QFontMetricsF::width(QChar ch) const -

1416 { -

1417

if (QChar::category(ch.unicode()) == QChar::Mark_NonSpacing)

never evaluated: QChar::category(ch.unicode()) == QChar::Mark_NonSpacing

1418

return 0.;

never executed: return 0.;

1419 -

1420

never executed (the execution status of this line is deduced): const int script = QUnicodeTables::script(ch);

1421

if (d->capital == QFont::SmallCaps && ch.isLower())

never executed (the execution status of this line is deduced): QFontEngine *engine;

1422

never evaluated: d->capital == QFont::SmallCaps

never evaluated: ch.isLower()

1423

engine = d->smallCapsFontPrivate()->engineForScript(script);

never executed: engine = d->smallCapsFontPrivate()->engineForScript(script);

1424 else -

1425

never executed: engine = d->engineForScript(script);

1426

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

1427 -

1428

QGlyphLayoutArray<8> glyphs;

never executed (the execution status of this line is deduced): d->alterCharForCapitalization(ch);

1429 -

1430

never executed (the execution status of this line is deduced): QGlyphLayoutArray<8> glyphs;

1431

int nglyphs = 7;

never executed (the execution status of this line is deduced): int nglyphs = 7;

1432

engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0);

never executed (the execution status of this line is deduced): engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, 0);

1433

return glyphs.advances_x[0].toReal();

never executed: return glyphs.advances_x[0].toReal();

1434 } -

1435 -

1436 /*! -

1437 Returns the bounding rectangle of the characters in the string -

1438 specified by \a text. The bounding rectangle always covers at least -

1439 the set of pixels the text would cover if drawn at (0, 0). -

1440 -

1441 Note that the bounding rectangle may extend to the left of (0, 0), -

1442 e.g. for italicized fonts, and that the width of the returned -

1443 rectangle might be different than what the width() method returns. -

1444 -

1445 If you want to know the advance width of the string (to layout -

1446 a set of strings next to each other), use width() instead. -

1447 -

1448 Newline characters are processed as normal characters, \e not as -

1449 linebreaks. -

1450 -

1451 The height of the bounding rectangle is at least as large as the -

1452 value returned height(). -

1453 -

1454 \sa width(), height(), QPainter::boundingRect() -

1455 */ -

1456 QRectF QFontMetricsF::boundingRect(const QString &text) const -

1457 { -

1458

int len = text.length();

never executed (the execution status of this line is deduced): int len = text.length();

1459

if (len == 0)

never evaluated: len == 0

1460

return QRectF();

never executed: return QRectF();

1461 -

1462

never executed (the execution status of this line is deduced): QStackTextEngine layout(text, QFont(d.data()));

1463

never executed (the execution status of this line is deduced): layout.ignoreBidi = true;

1464

glyph_metrics_t gm = layout.boundingBox(0, len);

never executed (the execution status of this line is deduced): layout.itemize();

1465

never executed (the execution status of this line is deduced): glyph_metrics_t gm = layout.boundingBox(0, len);

1466

return QRectF(gm.x.toReal(), gm.y.toReal(),

never executed: return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());

1467

gm.width.toReal(), gm.height.toReal());

never executed: return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());

1468 } -

1469 -

1470 /*! -

1471 Returns the bounding rectangle of the character \a ch relative to -

1472 the left-most point on the base line. -

1473 -

1474 Note that the bounding rectangle may extend to the left of (0, 0), -

1475 e.g. for italicized fonts, and that the text output may cover \e -

1476 all pixels in the bounding rectangle. -

1477 -

1478 Note that the rectangle usually extends both above and below the -

1479 base line. -

1480 -

1481 \sa width() -

1482 */ -

1483 QRectF QFontMetricsF::boundingRect(QChar ch) const -

1484 { -

1485

never executed (the execution status of this line is deduced): const int script = QUnicodeTables::script(ch);

1486

if (d->capital == QFont::SmallCaps && ch.isLower())

never executed (the execution status of this line is deduced): QFontEngine *engine;

1487

never evaluated: d->capital == QFont::SmallCaps

never evaluated: ch.isLower()

1488

engine = d->smallCapsFontPrivate()->engineForScript(script);

never executed: engine = d->smallCapsFontPrivate()->engineForScript(script);

1489 else -

1490

never executed: engine = d->engineForScript(script);

1491

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

1492 -

1493

QGlyphLayoutArray<10> glyphs;

never executed (the execution status of this line is deduced): d->alterCharForCapitalization(ch);

1494 -

1495

never executed (the execution status of this line is deduced): QGlyphLayoutArray<10> glyphs;

1496

int nglyphs = 9;

never executed (the execution status of this line is deduced): int nglyphs = 9;

1497

engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, QFontEngine::GlyphIndicesOnly);

never executed (the execution status of this line is deduced): engine->stringToCMap(&ch, 1, &glyphs, &nglyphs, QFontEngine::GlyphIndicesOnly);

1498

glyph_metrics_t gm = engine->boundingBox(glyphs.glyphs[0]);

never executed (the execution status of this line is deduced): glyph_metrics_t gm = engine->boundingBox(glyphs.glyphs[0]);

1499

return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());

never executed: return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());

1500 } -

1501 -

1502 /*! -

1503 \overload -

1504 -

1505 Returns the bounding rectangle of the characters in the given \a text. -

1506 This is the set of pixels the text would cover if drawn when constrained -

1507 to the bounding rectangle specified by \a rect. -

1508 -

1509 The \a flags argument is the bitwise OR of the following flags: -

1510 \list -

1511 \li Qt::AlignLeft aligns to the left border, except for -

1512 Arabic and Hebrew where it aligns to the right. -

1513 \li Qt::AlignRight aligns to the right border, except for -

1514 Arabic and Hebrew where it aligns to the left. -

1515 \li Qt::AlignJustify produces justified text. -

1516 \li Qt::AlignHCenter aligns horizontally centered. -

1517 \li Qt::AlignTop aligns to the top border. -

1518 \li Qt::AlignBottom aligns to the bottom border. -

1519 \li Qt::AlignVCenter aligns vertically centered -

1520 \li Qt::AlignCenter (== \c{Qt::AlignHCenter | Qt::AlignVCenter}) -

1521 \li Qt::TextSingleLine ignores newline characters in the text. -

1522 \li Qt::TextExpandTabs expands tabs (see below) -

1523 \li Qt::TextShowMnemonic interprets "&x" as \underline{x}; i.e., underlined. -

1524 \li Qt::TextWordWrap breaks the text to fit the rectangle. -

1525 \endlist -

1526 -

1527 Qt::Horizontal alignment defaults to Qt::AlignLeft and vertical -

1528 alignment defaults to Qt::AlignTop. -

1529 -

1530 If several of the horizontal or several of the vertical alignment -

1531 flags are set, the resulting alignment is undefined. -

1532 -

1533 These flags are defined in \l{Qt::AlignmentFlag}. -

1534 -

1535 If Qt::TextExpandTabs is set in \a flags, the following behavior is -

1536 used to interpret tab characters in the text: -

1537 \list -

1538 \li If \a tabArray is non-null, it specifies a 0-terminated sequence of -

1539 pixel-positions for tabs in the text. -

1540 \li If \a tabStops is non-zero, it is used as the tab spacing (in pixels). -

1541 \endlist -

1542 -

1543 Note that the bounding rectangle may extend to the left of (0, 0), -

1544 e.g. for italicized fonts. -

1545 -

1546 Newline characters are processed as line breaks. -

1547 -

1548 Despite the different actual character heights, the heights of the -

1549 bounding rectangles of "Yes" and "yes" are the same. -

1550 -

1551 The bounding rectangle returned by this function is somewhat larger -

1552 than that calculated by the simpler boundingRect() function. This -

1553 function uses the \l{minLeftBearing()}{maximum left} and -

1554 \l{minRightBearing()}{right} font bearings as is -

1555 necessary for multi-line text to align correctly. Also, -

1556 fontHeight() and lineSpacing() are used to calculate the height, -

1557 rather than individual character heights. -

1558 -

1559 \sa width(), QPainter::boundingRect(), Qt::Alignment -

1560 */ -

1561 QRectF QFontMetricsF::boundingRect(const QRectF &rect, int flags, const QString& text, -

1562 int tabStops, int *tabArray) const -

1563 { -

1564

int tabArrayLen = 0;

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

1565

if (tabArray)

partially evaluated: tabArray

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

0-14

1566

while (tabArray[tabArrayLen])

never evaluated: tabArray[tabArrayLen]

1567

tabArrayLen++;

never executed: tabArrayLen++;

1568 -

1569

QRectF rb;

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

1570

qt_format_text(QFont(d.data()), rect, flags | Qt::TextDontPrint, text, &rb, tabStops, tabArray,

executed (the execution status of this line is deduced): qt_format_text(QFont(d.data()), rect, flags | Qt::TextDontPrint, text, &rb, tabStops, tabArray,

1571

tabArrayLen, 0);

executed (the execution status of this line is deduced): tabArrayLen, 0);

1572

return rb;

executed: return rb;

Execution Count:14

1573 } -

1574 -

1575 /*! -

1576 Returns the size in pixels of the characters in the given \a text. -

1577 -

1578 The \a flags argument is the bitwise OR of the following flags: -

1579 \list -

1580 \li Qt::TextSingleLine ignores newline characters. -

1581 \li Qt::TextExpandTabs expands tabs (see below) -

1582 \li Qt::TextShowMnemonic interprets "&x" as \underline{x}; i.e., underlined. -

1583 \li Qt::TextWordBreak breaks the text to fit the rectangle. -

1584 \endlist -

1585 -

1586 These flags are defined in \l{Qt::TextFlags}. -

1587 -

1588 If Qt::TextExpandTabs is set in \a flags, the following behavior is -

1589 used to interpret tab characters in the text: -

1590 \list -

1591 \li If \a tabArray is non-null, it specifies a 0-terminated sequence of -

1592 pixel-positions for tabs in the text. -

1593 \li If \a tabStops is non-zero, it is used as the tab spacing (in pixels). -

1594 \endlist -

1595 -

1596 Newline characters are processed as line breaks. -

1597 -

1598 Note: Despite the different actual character heights, the heights of the -

1599 bounding rectangles of "Yes" and "yes" are the same. -

1600 -

1601 \sa boundingRect() -

1602 */ -

1603 QSizeF QFontMetricsF::size(int flags, const QString &text, int tabStops, int *tabArray) const -

1604 { -

1605

return boundingRect(QRectF(), flags | Qt::TextLongestVariant, text, tabStops, tabArray).size();

executed: return boundingRect(QRectF(), flags | Qt::TextLongestVariant, text, tabStops, tabArray).size();

Execution Count:14

1606 } -

1607 -

1608 /*! -

1609 \since 4.3 -

1610 -

1611 Returns a tight bounding rectangle around the characters in the -

1612 string specified by \a text. The bounding rectangle always covers -

1613 at least the set of pixels the text would cover if drawn at (0, -

1614 0). -

1615 -

1616 Note that the bounding rectangle may extend to the left of (0, 0), -

1617 e.g. for italicized fonts, and that the width of the returned -

1618 rectangle might be different than what the width() method returns. -

1619 -

1620 If you want to know the advance width of the string (to layout -

1621 a set of strings next to each other), use width() instead. -

1622 -

1623 Newline characters are processed as normal characters, \e not as -

1624 linebreaks. -

1625 -

1626 \warning Calling this method is very slow on Windows. -

1627 -

1628 \sa width(), height(), boundingRect() -

1629 */ -

1630 QRectF QFontMetricsF::tightBoundingRect(const QString &text) const -

1631 { -

1632

if (text.length() == 0)

never evaluated: text.length() == 0

1633

return QRect();

never executed: return QRect();

1634 -

1635

never executed (the execution status of this line is deduced): QStackTextEngine layout(text, QFont(d.data()));

1636

never executed (the execution status of this line is deduced): layout.ignoreBidi = true;

1637

glyph_metrics_t gm = layout.tightBoundingBox(0, text.length());

never executed (the execution status of this line is deduced): layout.itemize();

1638

never executed (the execution status of this line is deduced): glyph_metrics_t gm = layout.tightBoundingBox(0, text.length());

1639

return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());

never executed: return QRectF(gm.x.toReal(), gm.y.toReal(), gm.width.toReal(), gm.height.toReal());

1640 } -

1641 -

1642 /*! -

1643 \since 4.2 -

1644 -

1645 If the string \a text is wider than \a width, returns an elided -

1646 version of the string (i.e., a string with "..." in it). -

1647 Otherwise, returns the original string. -

1648 -

1649 The \a mode parameter specifies whether the text is elided on the -

1650 left (e.g., "...tech"), in the middle (e.g., "Tr...ch"), or on -

1651 the right (e.g., "Trol..."). -

1652 -

1653 The \a width is specified in pixels, not characters. -

1654 -

1655 The \a flags argument is optional and currently only supports -

1656 Qt::TextShowMnemonic as value. -

1657 */ -

1658 QString QFontMetricsF::elidedText(const QString &text, Qt::TextElideMode mode, qreal width, int flags) const -

1659 { -

1660

QString _text = text;

executed (the execution status of this line is deduced): QString _text = text;

1661

if (!(flags & Qt::TextLongestVariant)) {

partially evaluated: !(flags & Qt::TextLongestVariant)

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

0-6

1662

int posA = 0;

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

1663

int posB = _text.indexOf(QLatin1Char('\x9c'));

executed (the execution status of this line is deduced): int posB = _text.indexOf(QLatin1Char('\x9c'));

1664

while (posB >= 0) {

evaluated: posB >= 0

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:2

2-10

1665

QString portion = _text.mid(posA, posB - posA);

executed (the execution status of this line is deduced): QString portion = _text.mid(posA, posB - posA);

1666

if (size(flags, portion).width() <= width)

evaluated: size(flags, portion).width() <= width

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

4-6

1667

return portion;

executed: return portion;

Execution Count:4

1668

posA = posB + 1;

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

1669

posB = _text.indexOf(QLatin1Char('\x9c'), posA);

executed (the execution status of this line is deduced): posB = _text.indexOf(QLatin1Char('\x9c'), posA);

1670

executed: }

Execution Count:6

1671

_text = _text.mid(posA);

executed (the execution status of this line is deduced): _text = _text.mid(posA);

1672

QStackTextEngine engine(_text, QFont(d.data()));

executed: }

Execution Count:2

1673

executed (the execution status of this line is deduced): QStackTextEngine engine(_text, QFont(d.data()));

1674

return engine.elidedText(mode, QFixed::fromReal(width), flags);

executed: return engine.elidedText(mode, QFixed::fromReal(width), flags);

Execution Count:2

1675 } -

1676 -

1677 /*! -

1678 Returns the distance from the base line to where an underscore -

1679 should be drawn. -

1680 -

1681 \sa overlinePos(), strikeOutPos(), lineWidth() -

1682 */ -

1683 qreal QFontMetricsF::underlinePos() const -

1684 { -

1685

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1686

return engine->underlinePosition().toReal();

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

1687

never executed: return engine->underlinePosition().toReal();

1688 } -

1689 -

1690 /*! -

1691 Returns the distance from the base line to where an overline -

1692 should be drawn. -

1693 -

1694 \sa underlinePos(), strikeOutPos(), lineWidth() -

1695 */ -

1696 qreal QFontMetricsF::overlinePos() const -

1697 { -

1698

return ascent() + 1;

never executed: return ascent() + 1;

1699 } -

1700 -

1701 /*! -

1702 Returns the distance from the base line to where the strikeout -

1703 line should be drawn. -

1704 -

1705 \sa underlinePos(), overlinePos(), lineWidth() -

1706 */ -

1707 qreal QFontMetricsF::strikeOutPos() const -

1708 { -

1709

return ascent() / 3.;

never executed: return ascent() / 3.;

1710 } -

1711 -

1712 /*! -

1713 Returns the width of the underline and strikeout lines, adjusted -

1714 for the point size of the font. -

1715 -

1716 \sa underlinePos(), overlinePos(), strikeOutPos() -

1717 */ -

1718 qreal QFontMetricsF::lineWidth() const -

1719 { -

1720

QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

never executed (the execution status of this line is deduced): QFontEngine *engine = d->engineForScript(QUnicodeTables::Common);

1721