FCL/sf/mw/qt: comparison src/gui/text/qtextengine.cpp

equal deleted inserted replaced

-:ef0373b55136
+:758a864f9613
 for (int i = 0; i < si.num_glyphs; ++i)
 si.width += glyphs.advances_x[i];
 }
+static inline bool hasCaseChange(const QScriptItem &si)
+{
+return si.analysis.flags == QScriptAnalysis::SmallCaps ||
+si.analysis.flags == QScriptAnalysis::Uppercase ||
+si.analysis.flags == QScriptAnalysis::Lowercase;
+}
 #if defined(Q_WS_WINCE) //TODO
 // set the glyph attributes heuristically. Assumes a 1 to 1 relationship between chars and glyphs
 // and no reordering.
 // also computes logClusters heuristically
 static void heuristicSetGlyphAttributes(const QChar *uc, int length, QGlyphLayout *glyphs, unsigned short *logClusters, int num_glyphs)
 if (si.analysis.bidiLevel % 2)
 flags |= RightToLeft;
 if (option.useDesignMetrics())
 	flags |= DesignMetrics;
-attributes(); // pre-initialize char attributes
+// pre-initialize char attributes
+if (! attributes())
+return;
 const int len = length(item);
 int num_glyphs = length(item);
 const QChar *str = layoutData->string.unicode() + si.position;
 ushort upperCased[256];
-if (si.analysis.flags == QScriptAnalysis::SmallCaps || si.analysis.flags == QScriptAnalysis::Uppercase
+if (hasCaseChange(si)) {
-|| si.analysis.flags == QScriptAnalysis::Lowercase) {
 ushort *uc = upperCased;
 if (len > 256)
 uc = new ushort[len];
 for (int i = 0; i < len; ++i) {
 if(si.analysis.flags == QScriptAnalysis::Lowercase)
 }
 str = reinterpret_cast<const QChar *>(uc);
 }
 while (true) {
-ensureSpace(num_glyphs);
+if (! ensureSpace(num_glyphs)) {
+// If str is converted to uppercase/lowercase form with a new buffer,
+// we need to delete that buffer before return for error
+const ushort *uc = reinterpret_cast<const ushort *>(str);
+if (hasCaseChange(si) && uc != upperCased)
+delete [] uc;
+return;
+}
 num_glyphs = layoutData->glyphLayout.numGlyphs - layoutData->used;
 QGlyphLayout g = availableGlyphs(&si);
 unsigned short *log_clusters = logClusters(&si);
 si.num_glyphs = num_glyphs;
 layoutData->used += si.num_glyphs;
 const ushort *uc = reinterpret_cast<const ushort *>(str);
-if ((si.analysis.flags == QScriptAnalysis::SmallCaps || si.analysis.flags == QScriptAnalysis::Uppercase
+if (hasCaseChange(si) && uc != upperCased)
-|| si.analysis.flags == QScriptAnalysis::Lowercase)
-&& uc != upperCased)
 delete [] uc;
 }
 #endif
 static inline void moveGlyphData(const QGlyphLayout &destination, const QGlyphLayout &source, int num)
 entire_shaper_item.item.pos = si.position;
 entire_shaper_item.item.length = length(item);
 entire_shaper_item.item.bidiLevel = si.analysis.bidiLevel;
 HB_UChar16 upperCased[256]; // XXX what about making this 4096, so we don't have to extend it ever.
-if (si.analysis.flags == QScriptAnalysis::SmallCaps || si.analysis.flags == QScriptAnalysis::Uppercase
+if (hasCaseChange(si)) {
-|| si.analysis.flags == QScriptAnalysis::Lowercase) {
 HB_UChar16 *uc = upperCased;
 if (entire_shaper_item.item.length > 256)
 uc = new HB_UChar16[entire_shaper_item.item.length];
 for (uint i = 0; i < entire_shaper_item.item.length; ++i) {
 if(si.analysis.flags == QScriptAnalysis::Lowercase)
 entire_shaper_item.shaperFlags |= HB_ShaperFlag_NoKerning;
 if (option.useDesignMetrics())
 entire_shaper_item.shaperFlags |= HB_ShaperFlag_UseDesignMetrics;
 entire_shaper_item.num_glyphs = qMax(layoutData->glyphLayout.numGlyphs - layoutData->used, int(entire_shaper_item.item.length));
-ensureSpace(entire_shaper_item.num_glyphs);
+if (! ensureSpace(entire_shaper_item.num_glyphs)) {
+if (hasCaseChange(si))
+delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
+return;
+}
 QGlyphLayout initialGlyphs = availableGlyphs(&si).mid(0, entire_shaper_item.num_glyphs);
 if (!stringToGlyphs(&entire_shaper_item, &initialGlyphs, font)) {
-ensureSpace(entire_shaper_item.num_glyphs);
+if (! ensureSpace(entire_shaper_item.num_glyphs)) {
+if (hasCaseChange(si))
+delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
+return;
+}
 initialGlyphs = availableGlyphs(&si).mid(0, entire_shaper_item.num_glyphs);
 if (!stringToGlyphs(&entire_shaper_item, &initialGlyphs, font)) {
 // ############ if this happens there's a bug in the fontengine
-if ((si.analysis.flags == QScriptAnalysis::SmallCaps || si.analysis.flags == QScriptAnalysis::Uppercase
+if (hasCaseChange(si) && entire_shaper_item.string != upperCased)
-|| si.analysis.flags == QScriptAnalysis::Lowercase) && entire_shaper_item.string != upperCased)
 delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
 return;
 }
 }
 shaper_item.glyphIndicesPresent = true;
 remaining_glyphs -= shaper_item.initialGlyphCount;
 do {
-ensureSpace(glyph_pos + shaper_item.num_glyphs + remaining_glyphs);
+if (! ensureSpace(glyph_pos + shaper_item.num_glyphs + remaining_glyphs)) {
+if (hasCaseChange(si))
+delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
+return;
+}
 const QGlyphLayout g = availableGlyphs(&si).mid(glyph_pos);
 moveGlyphData(g.mid(shaper_item.num_glyphs), g.mid(shaper_item.initialGlyphCount), remaining_glyphs);
 shaper_item.glyphs = g.glyphs;
 //     qDebug("    -> item: script=%d num_glyphs=%d", shaper_item.script, shaper_item.num_glyphs);
 si.num_glyphs = glyph_pos;
 layoutData->used += si.num_glyphs;
-if ((si.analysis.flags == QScriptAnalysis::SmallCaps || si.analysis.flags == QScriptAnalysis::Uppercase)
+if (hasCaseChange(si) && entire_shaper_item.string != upperCased)
-&& entire_shaper_item.string != upperCased)
 delete [] const_cast<HB_UChar16 *>(entire_shaper_item.string);
 }
 static void init(QTextEngine *e)
 {
 {
 if (layoutData && layoutData->haveCharAttributes)
 return (HB_CharAttributes *) layoutData->memory;
 itemize();
-ensureSpace(layoutData->string.length());
+if (! ensureSpace(layoutData->string.length()))
+return NULL;
 QVarLengthArray<HB_ScriptItem> hbScriptItems(layoutData->items.size());
 for (int i = 0; i < layoutData->items.size(); ++i) {
 const QScriptItem &si = layoutData->items[i];
 int QTextEngine::findItem(int strPos) const
 {
 itemize();
+int left = 0;
-// ##### use binary search
+int right = layoutData->items.size()-1;
-int item;
+while(left <= right) {
-for (item = layoutData->items.size()-1; item > 0; --item) {
+int middle = ((right-left)/2)+left;
-if (layoutData->items[item].position <= strPos)
+if (strPos > layoutData->items[middle].position)
-break;
+left = middle+1;
-}
+else if(strPos < layoutData->items[middle].position)
-return item;
+right = middle-1;
+else {
+return middle;
+}
+}
+return right;
 }
 QFixed QTextEngine::width(int from, int len) const
 {
 itemize();
 glyph_metrics_t gm;
 for (int i = 0; i < layoutData->items.size(); i++) {
 const QScriptItem *si = layoutData->items.constData() + i;
-QFontEngine *fe = fontEngine(*si);
 int pos = si->position;
 int ilen = length(i);
 if (pos > from + len)
 break;
 int glyphStart = logClusters[charFrom];
 if (charFrom > 0 && logClusters[charFrom-1] == glyphStart)
 while (charFrom < ilen && logClusters[charFrom] == glyphStart)
 charFrom++;
 if (charFrom < ilen) {
+QFontEngine *fe = fontEngine(*si);
 glyphStart = logClusters[charFrom];
 int charEnd = from + len - 1 - pos;
 if (charEnd >= ilen)
 charEnd = ilen-1;
 int glyphEnd = logClusters[charEnd];
 gm.height = qMax(gm.height, m.height+gm.yoff);
 gm.xoff += m.xoff;
 gm.yoff += m.yoff;
 }
 }
-glyph_t glyph = glyphs.glyphs[logClusters[ilen - 1]];
-glyph_metrics_t gi = fe->boundingBox(glyph);
-if (gi.isValid())
-gm.width -= qRound(gi.xoff - gi.x - gi.width);
 }
 }
 return gm;
 }
 // justify line
 int maxJustify = 0;
 // don't include trailing white spaces when doing justification
 int line_length = line.length;
-const HB_CharAttributes *a = attributes()+line.from;
+const HB_CharAttributes *a = attributes();
+if (! a)
+return;
+a += line.from;
 while (line_length && a[line_length-1].whiteSpace)
 --line_length;
 // subtract one char more, as we can't justfy after the last character
 --line_length;
 memory = 0;
 allocated = 0;
 memory_on_stack = false;
 used = 0;
 hasBidi = false;
-inLayout = false;
+layoutState = LayoutEmpty;
 haveCharAttributes = false;
 logClustersPtr = 0;
 available_glyphs = 0;
 }
 glyphLayout.clear();
 memset(memory, 0, space_charAttributes*sizeof(void *));
 }
 used = 0;
 hasBidi = false;
-inLayout = false;
+layoutState = LayoutEmpty;
 haveCharAttributes = false;
 }
 QTextEngine::LayoutData::~LayoutData()
 {
 if (!memory_on_stack)
 free(memory);
 memory = 0;
 }
-void QTextEngine::LayoutData::reallocate(int totalGlyphs)
+bool QTextEngine::LayoutData::reallocate(int totalGlyphs)
 {
 Q_ASSERT(totalGlyphs >= glyphLayout.numGlyphs);
 if (memory_on_stack && available_glyphs >= totalGlyphs) {
 glyphLayout.grow(glyphLayout.data(), totalGlyphs);
-return;
+return true;
 }
 int space_charAttributes = sizeof(HB_CharAttributes)*string.length()/sizeof(void*) + 1;
 int space_logClusters = sizeof(unsigned short)*string.length()/sizeof(void*) + 1;
 int space_glyphs = QGlyphLayout::spaceNeededForGlyphLayout(totalGlyphs)/sizeof(void*) + 2;
 int newAllocated = space_charAttributes + space_glyphs + space_logClusters;
-Q_ASSERT(newAllocated >= allocated);
+// These values can be negative if the length of string/glyphs causes overflow,
+// we can't layout such a long string all at once, so return false here to
+// indicate there is a failure
+if (space_charAttributes < 0 || space_logClusters < 0 || space_glyphs < 0 || newAllocated < allocated) {
+layoutState = LayoutFailed;
+return false;
+}
 void **newMem = memory;
 newMem = (void **)::realloc(memory_on_stack ? 0 : memory, newAllocated*sizeof(void *));
-Q_CHECK_PTR(newMem);
+if (!newMem) {
-if (memory_on_stack && newMem)
+layoutState = LayoutFailed;
+return false;
+}
+if (memory_on_stack)
 memcpy(newMem, memory, allocated*sizeof(void *));
 memory = newMem;
 memory_on_stack = false;
 void **m = memory;
 memset(memory + allocated, 0, (space_preGlyphLayout - allocated)*sizeof(void *));
 glyphLayout.grow(reinterpret_cast<char *>(m), totalGlyphs);
 allocated = newAllocated;
+return true;
 }
 // grow to the new size, copying the existing data to the new layout
 void QGlyphLayout::grow(char *address, int totalGlyphs)
 {
 delete layoutData;
 layoutData = 0;
 } else {
 layoutData->used = 0;
 layoutData->hasBidi = false;
-layoutData->inLayout = false;
+layoutData->layoutState = LayoutEmpty;
 layoutData->haveCharAttributes = false;
 }
 for (int i = 0; i < lines.size(); ++i) {
 lines[i].justified = 0;
 lines[i].gridfitted = 0;
 switch (c.toLatin1()) {
 case '.':
 case ',':
 case '?':
 case '!':
+case '@':
+case '#':
+case '$':
 case ':':
 case ';':
 case '-':
 case '<':
 case '>':
 case '&':
 case '^':
 case '*':
 case '\'':
 case '"':
+case '`':
 case '~':
 case '|':
 return true;
 default:
 return false;
 QScriptItem &si = layoutData->items[i];
 if (!si.num_glyphs)
 shape(i);
 HB_CharAttributes *attributes = const_cast<HB_CharAttributes *>(this->attributes());
+if (!attributes)
+return QString();
 unsigned short *logClusters = this->logClusters(&si);
 QGlyphLayout glyphs = shapedGlyphs(&si);
 const int end = si.position + length(&si);
 for (int i = si.position; i < end - 1; ++i)
 const QFixed availableWidth = width - ellipsisWidth;
 if (availableWidth < 0)
 return QString();
 const HB_CharAttributes *attributes = this->attributes();
+if (!attributes)
+return QString();
 if (mode == Qt::ElideRight) {
 QFixed currentWidth;
 int pos = 0;
 int nextBreak = 0;

changeset 37	758a864f9613
parent 33	3e2da88830cd