// traverses to the top to check all of the parent contexes.
bool XLIFFHandler::hasContext(XliffContext ctx) const
{
for (int i = m_contextStack.count() - 1; i >= 0; --i) {
if (m_contextStack.at(i) == ctx)
return true;
}
return false;
}
void
BookmarkModel::setBookmarks(const QByteArray &bookmarks)
{
beginResetModel();
delete rootItem;
folderIcon = QApplication::style()->standardIcon(QStyle::SP_DirClosedIcon);
bookmarkIcon = QIcon(QLatin1String(":/trolltech/assistant/images/bookmark.png"));
rootItem = new BookmarkItem(DataVector() << tr("Name") << tr("Address")
<< true);
QStack<BookmarkItem*> parents;
QDataStream stream(bookmarks);
qint32 version;
stream >> version;
if (version < VERSION) {
stream.device()->seek(0);
BookmarkItem* toolbar = new BookmarkItem(DataVector() << tr("Toolbar Menu")
<< QLatin1String("Folder") << true);
rootItem->addChild(toolbar);
BookmarkItem* menu = new BookmarkItem(DataVector() << tr("Bookmarks Menu")
<< QLatin1String("Folder") << true);
rootItem->addChild(menu);
parents.push(menu);
} else {
parents.push(rootItem);
}
qint32 depth;
bool expanded;
QString name, url;
while (!stream.atEnd()) {
stream >> depth >> name >> url >> expanded;
while ((parents.count() - 1) != depth)
parents.pop();
BookmarkItem *item = new BookmarkItem(DataVector() << name << url << expanded);
if (url == QLatin1String("Folder")) {
parents.top()->addChild(item);
parents.push(item);
} else {
parents.top()->addChild(item);
}
}
cache.clear();
setupCache(index(0,0, QModelIndex().parent()));
endResetModel();
}
void StandardTreeModel::load(const QString &filename)
{
if (!filename.isEmpty())
m_filename = filename;
if (m_filename.isEmpty())
throw AQP::Error(tr("no filename specified"));
QFile file(m_filename);
if (!file.open(QIODevice::ReadOnly))
throw AQP::Error(file.errorString());
clear();
QStack<QStandardItem*> stack;
stack.push(invisibleRootItem());
QXmlStreamReader reader(&file);
while (!reader.atEnd()) {
reader.readNext();
if (reader.isStartElement()) {
if (reader.name() == TaskTag) {
const QString name = reader.attributes()
.value(NameAttribute).toString();
bool done = reader.attributes().value(DoneAttribute)
== "1";
StandardItem *nameItem = createNewTask(stack.top(),
name, done);
stack.push(nameItem);
}
else if (reader.name() == WhenTag) {
const QDateTime start = QDateTime::fromString(
reader.attributes().value(StartAttribute)
.toString(), Qt::ISODate);
const QDateTime end = QDateTime::fromString(
reader.attributes().value(EndAttribute)
.toString(), Qt::ISODate);
StandardItem *nameItem = static_cast<StandardItem*>(
stack.top());
nameItem->addDateTime(start, end);
}
}
else if (reader.isEndElement()) {
if (reader.name() == TaskTag)
stack.pop();
}
}
if (reader.hasError())
throw AQP::Error(reader.errorString());
if (stack.count() != 1 || stack.top() != invisibleRootItem())
throw AQP::Error(tr("loading error: possibly corrupt file"));
calculateTotalsFor(invisibleRootItem());
}
void Seeker::powerSeek( QString path ) {
this->flag = false ;
this->result.clear() ;
Node* node = this->seek( path ) ;
if ( node ) {
if ( node->record.count() ) {
//qDebug() << "get" << path ;
this->result.append( node ) ;
this->flag = true ;
}
else {
//qDebug() << "power seek" ;
QStack<Node*> current;
QStack<Node*> deeper;
current.push( this->current ) ;
while( current.count() > 0 && this->result.count() < 1 ) {
while( current.count() > 0 ) {
node = current.pop() ;
//qDebug() << QString( node->code ) ;
if ( node->record.count() )
this->result.append( node ) ;
else {
if ( this->result.count() < 1 ) {
for ( int i = 0; i < node->child.count(); i++ ) {
deeper.append( node->child[i] ) ;
}
}
}
}
current = deeper ;
deeper.clear() ;
}
}
}
//return this->result ;
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QStack<QString> files;
// Command Line setup
QCommandLineParser parser;
// Process options
parser.process( a );
int incorrectFiles = 0;
// Files were passed
for ( const QString & arg : parser.positionalArguments() ) {
QFileInfo finfo( arg );
QRegularExpression ext( "^(bsa|ba2)$", QRegularExpression::CaseInsensitiveOption );
if ( finfo.exists() && finfo.suffix().contains( ext ) ) {
files.push( arg );
} else {
incorrectFiles++;
}
}
MainWindow w;
a.setApplicationName( "Bethesda Archive Extractor" );
a.setApplicationDisplayName( "B.A.E." );
QDir::setCurrent( qApp->applicationDirPath() );
w.show();
if ( files.count() && !incorrectFiles ) {
w.openFile( files.pop() );
while ( !files.isEmpty() ) {
w.appendFile( files.pop() );
}
} else if ( incorrectFiles ) {
// Incorrect files passed
return 0;
}
return a.exec();
}
void
BookmarkModel::setBookmarks(const QByteArray &bookmarks)
{
beginResetModel();
delete rootItem;
folderIcon = QApplication::style()->standardIcon(QStyle::SP_DirClosedIcon);
bookmarkIcon = QIcon(QLatin1String(":/trolltech/assistant/images/bookmark.png"));
rootItem = new BookmarkItem(DataVector() << tr("Name") << tr("Address")
<< true);
BookmarkItem* item = new BookmarkItem(DataVector() << tr("Bookmarks Menu")
<< QLatin1String("Folder") << true);
rootItem->addChild(item);
QStack<BookmarkItem*> parents;
parents.push(item);
qint32 depth;
bool expanded;
QString name, url;
QDataStream stream(bookmarks);
while (!stream.atEnd()) {
stream >> depth >> name >> url >> expanded;
while ((parents.count() - 1) != depth)
parents.pop();
item = new BookmarkItem(DataVector() << name << url << expanded);
if (url == QLatin1String("Folder")) {
parents.top()->addChild(item);
parents.push(item);
} else {
parents.top()->addChild(item);
}
}
cache.clear();
const QModelIndex &root = index(0,0, QModelIndex());
setupCache(root);
cache.insert(static_cast<BookmarkItem*> (root.internalPointer()), root);
endResetModel();
}
int Repository::expire()
{
unsigned current = time(0L);
if (current < head_time)
return 0;
unsigned t;
QStack<QByteArray> keys;
head_time = (unsigned) -1;
RepoIterator it;
for (it=repo.begin(); it!=repo.end(); ++it)
{
t = it.value().timeout;
if (t <= current)
keys.push(it.key());
else
head_time = qMin(head_time, t);
}
int n = keys.count();
while (!keys.isEmpty())
remove(keys.pop());
return n;
}
void TraceLoader::parseTrace()
{
QList<ApiTraceFrame*> frames;
ApiTraceFrame *currentFrame = 0;
int frameCount = 0;
QStack<ApiTraceCall*> groups;
QVector<ApiTraceCall*> topLevelItems;
QVector<ApiTraceCall*> allCalls;
quint64 binaryDataSize = 0;
int lastPercentReport = 0;
trace::Call *call = m_parser.parse_call();
while (call) {
//std::cout << *call;
if (!currentFrame) {
currentFrame = new ApiTraceFrame();
currentFrame->number = frameCount;
++frameCount;
}
ApiTraceCall *apiCall =
apiCallFromTraceCall(call, m_helpHash, currentFrame, groups.isEmpty() ? 0 : groups.top(), this);
allCalls.append(apiCall);
if (groups.count() == 0) {
topLevelItems.append(apiCall);
}
if (call->flags & trace::CALL_FLAG_MARKER_PUSH) {
groups.push(apiCall);
} else if (call->flags & trace::CALL_FLAG_MARKER_POP) {
groups.top()->finishedAddingChildren();
groups.pop();
}
if (!groups.isEmpty()) {
groups.top()->addChild(apiCall);
}
if (apiCall->hasBinaryData()) {
QByteArray data =
apiCall->arguments()[apiCall->binaryDataIndex()].toByteArray();
binaryDataSize += data.size();
}
if (call->flags & trace::CALL_FLAG_END_FRAME) {
allCalls.squeeze();
topLevelItems.squeeze();
if (topLevelItems.count() == allCalls.count()) {
currentFrame->setCalls(allCalls, allCalls, binaryDataSize);
} else {
currentFrame->setCalls(topLevelItems, allCalls, binaryDataSize);
}
allCalls.clear();
groups.clear();
topLevelItems.clear();
frames.append(currentFrame);
currentFrame = 0;
binaryDataSize = 0;
if (frames.count() >= FRAMES_TO_CACHE) {
emit framesLoaded(frames);
frames.clear();
}
if (m_parser.percentRead() - lastPercentReport >= 5) {
emit parsed(m_parser.percentRead());
lastPercentReport = m_parser.percentRead();
}
}
delete call;
call = m_parser.parse_call();
}
//last frames won't have markers
// it's just a bunch of Delete calls for every object
// after the last SwapBuffers
if (currentFrame) {
allCalls.squeeze();
if (topLevelItems.count() == allCalls.count()) {
currentFrame->setCalls(allCalls, allCalls, binaryDataSize);
} else {
currentFrame->setCalls(topLevelItems, allCalls, binaryDataSize);
}
frames.append(currentFrame);
currentFrame = 0;
}
if (frames.count()) {
emit framesLoaded(frames);
}
}
// Convert binary CDX to text CDXML
QString ChemData::CDXToCDXML( QString fn )
{
QFile f( fn );
QString wholefile, proptag, stag;
QStack<QString *> tagstack;
QString *ts;
if ( !f.open( QIODevice::ReadOnly ) )
return wholefile;
qDebug() << "CDX ChemDraw binary file format.";
//QMessageBox::warning(r, "Can't read binary format",
// "This file is a ChemDraw (CDX) binary file, but this program cannot read it (yet :)");
// make a QByteArray
QByteArray cdxfile = f.readAll();
// for ( int c = 0; c < f.size(); c++ ) {
// cdxfile[c] = f.getch();
// }
bool opentag = false;
// start reading tags.
int ptr;
ptr = 28; // theoretically, position 28 is where the Document tag is
// the Document tag doesn't really matter to us; we ignore most of that
// stuff anyways...
wholefile.append( "<CDXML>" );
if ( ( cdxfile[ptr] == '0' ) && ( cdxfile[ptr + 1] == 'b' ) )
ptr = 30;
do { // until a <colortable>, <fonttable>, or <page> tag is found
if ( ( cdxfile[ptr] == '0' ) && ( cdxfile[ptr + 1] == '0' ) ) { // end tag?
if ( tagstack.count() > 0 ) {
if ( opentag )
wholefile.append( ">" );
ts = tagstack.top();
if ( ( *ts == "</t>" ) && ( stag.length() > 1 ) ) {
wholefile.append( stag );
stag = "";
}
ts = tagstack.pop();
wholefile.append( *ts );
ptr += 2;
opentag = false;
} else {
ptr += 2;
}
continue;
}
if ( cdxfile[ptr + 1] >= '0' ) { // it's a property
int moveforward = cdxfile[ptr + 3] * 256; // TODO + cdxfile[ptr+2] + 4;
QByteArray b( moveforward, '0' );
for ( int d = 0; d < moveforward; d++ )
b[d] = cdxfile[ptr + d];
proptag = ParseProperty( b );
if ( ( cdxfile[ptr] == '0' ) && ( cdxfile[ptr + 1] == '7' ) ) {
stag = proptag;
ptr += moveforward; // move past data
continue;
}
if ( proptag.length() > 1 ) {
wholefile.append( " " );
wholefile.append( proptag );
}
ptr += moveforward; // move past data
continue;
}
if ( ( unsigned char ) cdxfile[ptr + 1] == 'c' ) { // it's an object
if ( ( tagstack.count() > 0 ) && opentag )
wholefile.append( ">" );
opentag = true;
int local_id = 0;
local_id = local_id + ( unsigned char ) cdxfile[ptr + 2];
local_id = local_id + ( unsigned char ) cdxfile[ptr + 3] * 256;
QString s_id;
s_id.setNum( local_id );
if ( cdxfile[ptr] == '1' ) { // page object
wholefile.append( "<page " );
wholefile.append( "id=\"" );
wholefile.append( s_id );
wholefile.append( "\"" );
ts = new QString( "</page>" );
tagstack.push( ts );
ptr += 6; // move past tag and ID
continue;
}
if ( cdxfile[ptr] == '3' ) { // fragment object
wholefile.append( "<fragment " );
wholefile.append( "id=\"" );
wholefile.append( s_id );
wholefile.append( "\"" );
ts = new QString( "</fragment>" );
tagstack.push( ts );
ptr += 6; // move past tag and ID
continue;
}
if ( cdxfile[ptr] == '4' ) { // node object
wholefile.append( "<n " );
wholefile.append( "id=\"" );
wholefile.append( s_id );
wholefile.append( "\"" );
ts = new QString( "</n>" );
tagstack.push( ts );
ptr += 6; // move past tag and ID
continue;
}
if ( cdxfile[ptr] == '5' ) { // bond object
wholefile.append( "<b " );
wholefile.append( "id=\"" );
wholefile.append( s_id );
wholefile.append( "\"" );
opentag = false;
ts = new QString( "/>" );
tagstack.push( ts );
ptr += 6; // move past tag and ID
continue;
}
if ( cdxfile[ptr] == '6' ) { // text object
wholefile.append( "<t " );
wholefile.append( "id=\"" );
wholefile.append( s_id );
wholefile.append( "\"" );
ts = new QString( "</t>" );
tagstack.push( ts );
ptr += 6; // move past tag and ID
continue;
}
if ( cdxfile[ptr] == '7' ) { // graphic object
wholefile.append( "<graphic " );
wholefile.append( "id=\"" );
wholefile.append( s_id );
wholefile.append( "\"" );
opentag = false;
ts = new QString( "/>" );
tagstack.push( ts );
ptr += 6; // move past tag and ID
continue;
}
}
} while ( ptr < cdxfile.size() );
wholefile.append( "</CDXML>" );
qDebug() << wholefile;
return wholefile;
}
qreal KoEnhancedPathFormula::evaluate()
{
// shortcut
if( m_error != ErrorNone )
return 0.0;
// lazy evaluation
if( ! m_compiled )
{
TokenList tokens = scan( m_text );
if( m_error != ErrorNone )
debugTokens( tokens );
if( ! compile( tokens ) )
{
debugOpcodes();
m_error = ErrorCompile;
return false;
}
m_compiled = true;
}
QStack<QVariant> stack;
int index = 0;
if( ! m_valid )
{
m_error = ErrorParse;
return 0.0;
}
for( int pc = 0; pc < m_codes.count(); pc++ )
{
QVariant ret; // for the function caller
Opcode& opcode = m_codes[pc];
index = opcode.index;
switch( opcode.type )
{
// no operation
case Opcode::Nop:
break;
// load a constant, push to stack
case Opcode::Load:
stack.push( m_constants[index] );
break;
// unary operation
case Opcode::Neg:
{
bool success = false;
qreal value = stack.pop().toDouble( &success );
if( success ) // do nothing if we got an error
value *= -1.0;
stack.push( QVariant( value ) );
}
break;
// binary operation: take two values from stack, do the operation,
// push the result to stack
case Opcode::Add:
{
qreal val2 = stack.pop().toDouble();
qreal val1 = stack.pop().toDouble();
stack.push( QVariant( val1 + val2 ) );
}
break;
case Opcode::Sub:
{
qreal val2 = stack.pop().toDouble();
qreal val1 = stack.pop().toDouble();
stack.push( QVariant( val1 - val2 ) );
}
break;
case Opcode::Mul:
{
qreal val2 = stack.pop().toDouble();
qreal val1 = stack.pop().toDouble();
stack.push( QVariant( val1 * val2 ) );
}
break;
case Opcode::Div:
{
qreal val2 = stack.pop().toDouble();
qreal val1 = stack.pop().toDouble();
stack.push( QVariant( val1 / val2 ) );
}
break;
case Opcode::Ref:
{
QString reference = m_constants[index].toString();
// push function name if it is a function, else push evaluated reference
Function function = matchFunction( reference );
if( FunctionUnknown == function )
stack.push( QVariant( m_parent->evaluateReference( reference ) ) );
else
stack.push( function );
}
break;
// calling function
case Opcode::Function:
{
// sanity check, this should not happen unless opcode is wrong
// (i.e. there's a bug in the compile() function)
if( stack.count() < index )
{
kWarning() << "not enough arguments for function " << m_text;
m_error = ErrorValue; // not enough arguments
return 0.0;
}
/// prepare function arguments
QList<qreal> args;
for( ; index; index-- )
{
qreal value = stack.pop().toDouble();
args.push_front( value );
}
// function identifier as int value
int function = stack.pop().toInt();
stack.push( QVariant( evaluateFunction( (Function)function, args ) ) );
}
break;
default:
break;
}
}
// more than one value in stack ? unsuccessful execution...
if( stack.count() != 1 )
{
m_error = ErrorValue;
return 0.0;
}
return stack.pop().toDouble();
}
LensDialog::LensDialog(QWidget* parent, ScribusDoc *doc) : QDialog(parent)
{
setupUi(this);
buttonRemove->setEnabled(false);
setModal(true);
buttonZoomOut->setIcon(QIcon(loadIcon("16/zoom-out.png")));
buttonZoomI->setIcon(QIcon(loadIcon("16/zoom-in.png")));
PageItem *currItem;
double gx, gy, gh, gw;
doc->m_Selection->setGroupRect();
doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
uint selectedItemCount = doc->m_Selection->count();
QStack<PageItem*> groupStack;
QStack<QGraphicsPathItem*> groupStack2;
QStack<PageItem*> groupStack3;
groupStack2.push(0);
for (uint i = 0; i < selectedItemCount; ++i)
{
currItem = doc->m_Selection->itemAt(i);
FPointArray path = currItem->PoLine;
QPainterPath pp;
if (currItem->itemType() == PageItem::PolyLine)
pp = path.toQPainterPath(false);
else
pp = path.toQPainterPath(true);
origPath.append(pp);
QGraphicsPathItem* pItem = new QGraphicsPathItem(pp, groupStack2.top());
if (groupStack2.top() == 0)
{
scene.addItem(pItem);
pItem->setPos(currItem->xPos() - gx, currItem->yPos() - gy);
pItem->rotate(currItem->rotation());
}
else
{
PageItem* parent = groupStack3.top();
QMatrix mm;
mm.rotate(-parent->rotation());
mm.translate(-parent->xPos(), -parent->yPos());
pItem->setPos(mm.map(QPointF(currItem->xPos(), currItem->yPos())));
}
pItem->setZValue(i);
origPathItem.append(pItem);
if (((currItem->fillColor() == CommonStrings::None) && (currItem->GrType == 0)) || (currItem->controlsGroup()))
pItem->setBrush(Qt::NoBrush);
else
{
if (currItem->GrType != 0)
{
if (currItem->GrType != 8)
{
QGradient pat;
double x1 = currItem->GrStartX;
double y1 = currItem->GrStartY;
double x2 = currItem->GrEndX;
double y2 = currItem->GrEndY;
switch (currItem->GrType)
{
case 1:
case 2:
case 3:
case 4:
case 6:
pat = QLinearGradient(x1, y1, x2, y2);
break;
case 5:
case 7:
pat = QRadialGradient(x1, y1, sqrt(pow(x2 - x1, 2) + pow(y2 - y1,2)), x1, y1);
break;
}
QList<VColorStop*> colorStops = currItem->fill_gradient.colorStops();
QColor qStopColor;
for( int offset = 0 ; offset < colorStops.count() ; offset++ )
{
qStopColor = colorStops[ offset ]->color;
int h, s, v, sneu, vneu;
int shad = colorStops[offset]->shade;
qStopColor.getHsv(&h, &s, &v);
sneu = s * shad / 100;
vneu = 255 - ((255 - v) * shad / 100);
qStopColor.setHsv(h, sneu, vneu);
qStopColor.setAlphaF(colorStops[offset]->opacity);
pat.setColorAt(colorStops[ offset ]->rampPoint, qStopColor);
}
pItem->setBrush(pat);
}
else if ((currItem->GrType == 8) && (!currItem->pattern().isEmpty()) && (doc->docPatterns.contains(currItem->pattern())))
{
double patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation;
currItem->patternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
QMatrix qmatrix;
qmatrix.translate(patternOffsetX, patternOffsetY);
qmatrix.rotate(patternRotation);
qmatrix.scale(patternScaleX / 100.0, patternScaleY / 100.0);
QImage pat = *doc->docPatterns[currItem->pattern()].getPattern();
QBrush brush = QBrush(pat);
brush.setMatrix(qmatrix);
pItem->setBrush(brush);
}
}
else
{
QColor paint = ScColorEngine::getShadeColorProof(doc->PageColors[currItem->fillColor()], doc, currItem->fillShade());
paint.setAlphaF(1.0 - currItem->fillTransparency());
pItem->setBrush(paint);
}
}
if ((currItem->lineColor() == CommonStrings::None) || (currItem->controlsGroup()))
pItem->setPen(Qt::NoPen);
else
{
QColor paint = ScColorEngine::getShadeColorProof(doc->PageColors[currItem->lineColor()], doc, currItem->lineShade());
paint.setAlphaF(1.0 - currItem->lineTransparency());
pItem->setPen(QPen(paint, currItem->lineWidth(), currItem->lineStyle(), currItem->lineEnd(), currItem->lineJoin()));
}
if (currItem->controlsGroup())
{
groupStack.push(currItem->groupsLastItem);
groupStack2.push(pItem);
groupStack3.push(currItem);
pItem->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
}
if (groupStack.count() != 0)
{
while (currItem == groupStack.top())
{
groupStack3.pop();
groupStack2.pop();
groupStack.pop();
if (groupStack.count() == 0)
break;
}
}
}
previewWidget->setRenderHint(QPainter::Antialiasing);
previewWidget->setScene(&scene);
isFirst = true;
addLens();
connect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
connect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
connect(spinRadius, SIGNAL(valueChanged(double)), this, SLOT(setNewLensRadius(double)));
connect(spinStrength, SIGNAL(valueChanged(double)), this, SLOT(setNewLensStrength(double)));
connect(buttonAdd, SIGNAL(clicked()), this, SLOT(addLens()));
connect(buttonRemove, SIGNAL(clicked()), this, SLOT(removeLens()));
connect(buttonMagnify, SIGNAL(toggled(bool)), this, SLOT(changeLens()));
connect(buttonZoomI, SIGNAL(clicked()), this, SLOT(doZoomIn()));
connect(buttonZoomOut, SIGNAL(clicked()), this, SLOT(doZoomOut()));
connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
connect(&scene, SIGNAL(selectionChanged()), this, SLOT(selectionHasChanged()));
}
void QQuickStyledTextPrivate::parse()
{
QList<QTextLayout::FormatRange> ranges;
QStack<QTextCharFormat> formatStack;
QString drawText;
drawText.reserve(text.count());
updateImagePositions = !imgTags->isEmpty();
int textStart = 0;
int textLength = 0;
int rangeStart = 0;
bool formatChanged = false;
const QChar *ch = text.constData();
while (!ch->isNull()) {
if (*ch == lessThan) {
if (textLength) {
appendText(text, textStart, textLength, drawText);
} else if (prependSpace) {
drawText.append(space);
prependSpace = false;
hasSpace = true;
}
if (rangeStart != drawText.length() && formatStack.count()) {
if (formatChanged) {
QTextLayout::FormatRange formatRange;
formatRange.format = formatStack.top();
formatRange.start = rangeStart;
formatRange.length = drawText.length() - rangeStart;
ranges.append(formatRange);
formatChanged = false;
} else if (ranges.count()) {
ranges.last().length += drawText.length() - rangeStart;
}
}
rangeStart = drawText.length();
++ch;
if (*ch == slash) {
++ch;
if (parseCloseTag(ch, text, drawText)) {
if (formatStack.count()) {
formatChanged = true;
formatStack.pop();
}
}
} else {
QTextCharFormat format;
if (formatStack.count())
format = formatStack.top();
if (parseTag(ch, text, drawText, format)) {
formatChanged = true;
formatStack.push(format);
}
}
textStart = ch - text.constData() + 1;
textLength = 0;
} else if (*ch == ampersand) {
++ch;
appendText(text, textStart, textLength, drawText);
parseEntity(ch, text, drawText);
textStart = ch - text.constData() + 1;
textLength = 0;
} else if (ch->isSpace()) {
if (textLength)
appendText(text, textStart, textLength, drawText);
if (!preFormat) {
prependSpace = !hasSpace;
for (const QChar *n = ch + 1; !n->isNull() && n->isSpace(); ++n)
ch = n;
hasNewLine = false;
} else if (*ch == lineFeed) {
drawText.append(QChar(QChar::LineSeparator));
hasNewLine = true;
} else {
drawText.append(QChar(QChar::Nbsp));
hasNewLine = false;
}
textStart = ch - text.constData() + 1;
textLength = 0;
} else {
++textLength;
}
if (!ch->isNull())
++ch;
}
if (textLength)
appendText(text, textStart, textLength, drawText);
if (rangeStart != drawText.length() && formatStack.count()) {
if (formatChanged) {
QTextLayout::FormatRange formatRange;
formatRange.format = formatStack.top();
formatRange.start = rangeStart;
formatRange.length = drawText.length() - rangeStart;
ranges.append(formatRange);
} else if (ranges.count()) {
ranges.last().length += drawText.length() - rangeStart;
}
}
layout.setText(drawText);
layout.setAdditionalFormats(ranges);
}
void QDeclarativeStyledTextPrivate::parse()
{
QList<QTextLayout::FormatRange> ranges;
QStack<QTextCharFormat> formatStack;
QString drawText;
drawText.reserve(text.count());
int textStart = 0;
int textLength = 0;
int rangeStart = 0;
const QChar *ch = text.constData();
while (!ch->isNull()) {
if (*ch == lessThan) {
if (textLength)
drawText.append(QStringRef(&text, textStart, textLength));
if (rangeStart != drawText.length() && formatStack.count()) {
QTextLayout::FormatRange formatRange;
formatRange.format = formatStack.top();
formatRange.start = rangeStart;
formatRange.length = drawText.length() - rangeStart;
ranges.append(formatRange);
}
rangeStart = drawText.length();
++ch;
if (*ch == slash) {
++ch;
if (parseCloseTag(ch, text)) {
if (formatStack.count())
formatStack.pop();
}
} else {
QTextCharFormat format;
if (formatStack.count())
format = formatStack.top();
if (parseTag(ch, text, drawText, format))
formatStack.push(format);
}
textStart = ch - text.constData() + 1;
textLength = 0;
} else if (*ch == ampersand) {
++ch;
drawText.append(QStringRef(&text, textStart, textLength));
parseEntity(ch, text, drawText);
textStart = ch - text.constData() + 1;
textLength = 0;
} else {
++textLength;
}
if (!ch->isNull())
++ch;
}
if (textLength)
drawText.append(QStringRef(&text, textStart, textLength));
if (rangeStart != drawText.length() && formatStack.count()) {
QTextLayout::FormatRange formatRange;
formatRange.format = formatStack.top();
formatRange.start = rangeStart;
formatRange.length = drawText.length() - rangeStart;
ranges.append(formatRange);
}
layout.setText(drawText);
layout.setAdditionalFormats(ranges);
}
_class * readFromXML(QString fileXml) {
_class *root = NULL;
// init xml stream
QFile file(fileXml);
QXmlStreamReader xmlReader;
//QString line;
if ( !file.open(QIODevice::ReadOnly) )
return false;
{
QTextStream t( &file );
// stream.setCodec("CP-866");
xmlReader.addData(t.readAll());
}
// start reading
QStack<_specXMLElement *> stackElements;
while(!xmlReader.atEnd())
{
if(xmlReader.isCharacters() && stackElements.count() != 0)
{
_specXMLElement *pElemTop = stackElements.top();
if(pElemTop->hasBody())
pElemTop->setBody(xmlReader.readElementText());
}
if(xmlReader.isStartElement())
{
QString strName = xmlReader.name().toString();
_specXMLElement *elem = createElement(strName);
_specXMLElement *parentElem = (stackElements.count() != 0) ? stackElements.top() : NULL;
if(stackElements.count() == 0)
root = (_class *)elem;
if(parentElem != NULL)
parentElem->addChildElement(strName,elem);
stackElements.push(elem);
for(int i = 0; i < xmlReader.attributes().count(); i++)
{
QXmlStreamAttribute attr = xmlReader.attributes().at(i);
elem->setAttribute(attr.name().toString(), attr.value().toString());
}
}
if(xmlReader.isEndElement())
{
stackElements.pop();
}
xmlReader.readNext();
};
if(xmlReader.hasError())
{
return NULL;
// std::cout << xmlReader.errorString().toStdString();
}
return root;
};
void QmlProfilerStatisticsModel::loadData(qint64 rangeStart, qint64 rangeEnd)
{
clear();
qint64 qmlTime = 0;
qint64 lastEndTime = 0;
QHash <int, QVector<qint64> > durations;
const bool checkRanges = (rangeStart != -1) && (rangeEnd != -1);
const QVector<QmlProfilerDataModel::QmlEventData> &eventList
= d->modelManager->qmlModel()->getEvents();
const QVector<QmlProfilerDataModel::QmlEventTypeData> &typesList
= d->modelManager->qmlModel()->getEventTypes();
// used by binding loop detection
QStack<const QmlProfilerDataModel::QmlEventData*> callStack;
callStack.push(0); // artificial root
for (int i = 0; i < eventList.size(); ++i) {
const QmlProfilerDataModel::QmlEventData *event = &eventList[i];
const QmlProfilerDataModel::QmlEventTypeData *type = &typesList[event->typeIndex()];
if (!d->acceptedTypes.contains(type->rangeType))
continue;
if (checkRanges) {
if ((event->startTime() + event->duration() < rangeStart)
|| (event->startTime() > rangeEnd))
continue;
}
// update stats
QmlEventStats *stats = &d->data[event->typeIndex()];
stats->duration += event->duration();
stats->durationSelf += event->duration();
if (event->duration() < stats->minTime)
stats->minTime = event->duration();
if (event->duration() > stats->maxTime)
stats->maxTime = event->duration();
stats->calls++;
// for median computing
durations[event->typeIndex()].append(event->duration());
// qml time computation
if (event->startTime() > lastEndTime) { // assume parent event if starts before last end
qmlTime += event->duration();
lastEndTime = event->startTime() + event->duration();
}
//
// binding loop detection
//
const QmlProfilerDataModel::QmlEventData *potentialParent = callStack.top();
while (potentialParent && !(potentialParent->startTime() + potentialParent->duration() >
event->startTime())) {
callStack.pop();
potentialParent = callStack.top();
}
// check whether event is already in stack
for (int ii = 1; ii < callStack.size(); ++ii) {
if (callStack.at(ii)->typeIndex() == event->typeIndex()) {
d->eventsInBindingLoop.insert(event->typeIndex());
break;
}
}
if (callStack.count() > 1)
d->data[callStack.top()->typeIndex()].durationSelf -= event->duration();
callStack.push(event);
d->modelManager->modelProxyCountUpdated(d->modelId, i, eventList.count()*2);
}
// post-process: calc mean time, median time, percentoftime
int i = d->data.size();
int total = i * 2;
for (QHash<int, QmlEventStats>::iterator it = d->data.begin(); it != d->data.end(); ++it) {
QmlEventStats* stats = &it.value();
if (stats->calls > 0)
stats->timePerCall = stats->duration / (double)stats->calls;
QVector<qint64> eventDurations = durations[it.key()];
if (!eventDurations.isEmpty()) {
Utils::sort(eventDurations);
stats->medianTime = eventDurations.at(eventDurations.count()/2);
}
stats->percentOfTime = stats->duration * 100.0 / qmlTime;
stats->percentSelf = stats->durationSelf * 100.0 / qmlTime;
d->modelManager->modelProxyCountUpdated(d->modelId, i++, total);
}
// set binding loop flag
foreach (int typeIndex, d->eventsInBindingLoop)
d->data[typeIndex].isBindingLoop = true;
// insert root event
QmlEventStats rootEvent;
rootEvent.duration = rootEvent.minTime = rootEvent.maxTime = rootEvent.timePerCall
= rootEvent.medianTime = qmlTime + 1;
rootEvent.durationSelf = 1;
rootEvent.calls = 1;
rootEvent.percentOfTime = 100.0;
rootEvent.percentSelf = 1.0 / rootEvent.duration;
d->data.insert(-1, rootEvent);
d->modelManager->modelProxyCountUpdated(d->modelId, 1, 1);
emit dataAvailable();
}
QVector<ApiTraceCall*>
TraceLoader::fetchFrameContents(ApiTraceFrame *currentFrame)
{
Q_ASSERT(currentFrame);
if (currentFrame->isLoaded()) {
return currentFrame->calls();
}
if (m_parser.supportsOffsets()) {
unsigned frameIdx = currentFrame->number;
int numOfCalls = numberOfCallsInFrame(frameIdx);
if (numOfCalls) {
quint64 binaryDataSize = 0;
QStack<ApiTraceCall*> groups;
QVector<ApiTraceCall*> topLevelItems;
QVector<ApiTraceCall*> allCalls(numOfCalls);
const FrameBookmark &frameBookmark = m_frameBookmarks[frameIdx];
m_parser.setBookmark(frameBookmark.start);
trace::Call *call;
int parsedCalls = 0;
while ((call = m_parser.parse_call())) {
ApiTraceCall *apiCall =
apiCallFromTraceCall(call, m_helpHash,
currentFrame, groups.isEmpty() ? 0 : groups.top(), this);
Q_ASSERT(apiCall);
Q_ASSERT(parsedCalls < allCalls.size());
allCalls[parsedCalls++] = apiCall;
if (groups.count() == 0) {
topLevelItems.append(apiCall);
} else {
groups.top()->addChild(apiCall);
}
if (call->flags & trace::CALL_FLAG_MARKER_PUSH) {
groups.push(apiCall);
} else if (call->flags & trace::CALL_FLAG_MARKER_POP) {
if (groups.count()) {
groups.top()->finishedAddingChildren();
groups.pop();
}
}
if (apiCall->hasBinaryData()) {
QByteArray data =
apiCall->arguments()[
apiCall->binaryDataIndex()].toByteArray();
binaryDataSize += data.size();
}
delete call;
if (apiCall->flags() & trace::CALL_FLAG_END_FRAME) {
break;
}
}
// There can be fewer parsed calls when call in different
// threads cross the frame boundary
Q_ASSERT(parsedCalls <= numOfCalls);
Q_ASSERT(parsedCalls <= allCalls.size());
allCalls.resize(parsedCalls);
allCalls.squeeze();
Q_ASSERT(parsedCalls <= currentFrame->numChildrenToLoad());
if (topLevelItems.count() == allCalls.count()) {
emit frameContentsLoaded(currentFrame, allCalls,
allCalls, binaryDataSize);
} else {
emit frameContentsLoaded(currentFrame, topLevelItems,
allCalls, binaryDataSize);
}
return allCalls;
}
}
return QVector<ApiTraceCall*>();
}
void EPSPlug::parseOutput(QString fn, bool eps)
{
QString tmp, token, params, lasttoken, lastPath, currPath;
int z, lcap, ljoin, dc, pagecount;
int failedImages = 0;
double dcp;
bool fillRuleEvenOdd = true;
PageItem* ite;
QStack<PageItem*> groupStack;
QStack< QList<PageItem*> > groupStackP;
QStack<int> gsStack;
QStack<uint> gsStackMarks;
QFile f(fn);
lasttoken = "";
pagecount = 1;
if (f.open(QIODevice::ReadOnly))
{
int fProgress = 0;
int fSize = (int) f.size();
if (progressDialog) {
progressDialog->setTotalSteps("GI", fSize);
qApp->processEvents();
}
lastPath = "";
currPath = "";
LineW = 0;
Opacity = 1;
CurrColor = CommonStrings::None;
JoinStyle = Qt::MiterJoin;
CapStyle = Qt::FlatCap;
DashPattern.clear();
ScTextStream ts(&f);
int line_cnt = 0;
while (!ts.atEnd() && !cancel)
{
tmp = "";
tmp = ts.readLine();
if (progressDialog && (++line_cnt % 100 == 0)) {
int fPos = f.pos();
int progress = static_cast<int>(ceil(fPos / (double) fSize * 100));
if (progress > fProgress)
{
progressDialog->setProgress("GI", fPos);
qApp->processEvents();
fProgress = progress;
}
}
token = tmp.section(' ', 0, 0);
params = tmp.section(' ', 1, -1, QString::SectionIncludeTrailingSep);
if (lasttoken == "sp" && !eps && token != "sp" ) //av: messes up anyway: && (!interactive))
{
m_Doc->addPage(pagecount);
m_Doc->view()->addPage(pagecount, true);
pagecount++;
}
if (token == "n")
{
Coords.resize(0);
FirstM = true;
WasM = false;
ClosedPath = false;
}
else if (token == "m")
WasM = true;
else if (token == "c")
{
Curve(&Coords, params);
currPath += params;
}
else if (token == "l")
{
LineTo(&Coords, params);
currPath += params;
}
else if (token == "fill-winding")
{
fillRuleEvenOdd = false;
}
else if (token == "fill-evenodd")
{
fillRuleEvenOdd = true;
}
else if (token == "f")
{
//TODO: pattern -> Imageframe + Clip
if (Coords.size() != 0)
{
if ((Elements.count() != 0) && (lastPath == currPath))
{
ite = Elements.last();
ite->setFillColor(CurrColor);
ite->setFillTransparency(1.0 - Opacity);
lastPath = "";
}
else
{
if (ClosedPath)
z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColor, CommonStrings::None);
else
z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CurrColor, CommonStrings::None);
ite = m_Doc->Items->at(z);
ite->PoLine = Coords.copy(); //FIXME: try to avoid copy if FPointArray when properly shared
ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
ite->ClipEdited = true;
ite->FrameType = 3;
ite->fillRule = (fillRuleEvenOdd);
FPoint wh = getMaxClipF(&ite->PoLine);
ite->setWidthHeight(wh.x(),wh.y());
ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
ite->setFillTransparency(1.0 - Opacity);
ite->setTextFlowMode(PageItem::TextFlowDisabled);
m_Doc->AdjustItemSize(ite);
if (ite->itemType() == PageItem::Polygon)
ite->ContourLine = ite->PoLine.copy();
if ((groupStack.count() != 0) && (groupStackP.count() != 0))
groupStackP.top().append(ite);
Elements.append(ite);
lastPath = currPath;
}
currPath = "";
}
}
else if (token == "s")
{
if (Coords.size() != 0)
{
// LineW = qMax(LineW, 0.01); // Set Linewidth to be a least 0.01 pts, a Stroke without a Linewidth makes no sense
if ((Elements.count() != 0) && (lastPath == currPath))
{
ite = Elements.last();
ite->setLineColor(CurrColor);
ite->setLineWidth(LineW);
ite->PLineEnd = CapStyle;
ite->PLineJoin = JoinStyle;
ite->setLineTransparency(1.0 - Opacity);
ite->DashOffset = DashOffset;
ite->DashValues = DashPattern;
}
else
{
if (ClosedPath)
z = m_Doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColor);
else
z = m_Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, baseX, baseY, 10, 10, LineW, CommonStrings::None, CurrColor);
ite = m_Doc->Items->at(z);
ite->PoLine = Coords.copy(); //FIXME: try to avoid copy when FPointArray is properly shared
ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
ite->ClipEdited = true;
ite->FrameType = 3;
ite->PLineEnd = CapStyle;
ite->PLineJoin = JoinStyle;
ite->DashOffset = DashOffset;
ite->DashValues = DashPattern;
FPoint wh = getMaxClipF(&ite->PoLine);
ite->setWidthHeight(wh.x(), wh.y());
ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
ite->setLineTransparency(1.0 - Opacity);
m_Doc->AdjustItemSize(ite);
if (ite->itemType() == PageItem::Polygon)
ite->ContourLine = ite->PoLine.copy();
ite->setLineWidth(LineW);
ite->setTextFlowMode(PageItem::TextFlowDisabled);
if ((groupStack.count() != 0) && (groupStackP.count() != 0))
groupStackP.top().append(ite);
Elements.append(ite);
}
lastPath = "";
currPath = "";
}
}
else if (token == "co")
CurrColor = parseColor(params, eps);
else if (token == "corgb")
CurrColor = parseColor(params, eps, colorModelRGB);
else if (token == "ci")
{
if (Coords.size() != 0)
{
QPainterPath tmpPath = Coords.toQPainterPath(true);
tmpPath = boundingBoxRect.intersected(tmpPath);
if ((tmpPath.boundingRect().width() != 0) && (tmpPath.boundingRect().height() != 0))
{
clipCoords.fromQPainterPath(tmpPath);
z = m_Doc->itemAdd(PageItem::Group, PageItem::Rectangle, baseX, baseY, 10, 10, 0, CommonStrings::None, CommonStrings::None);
ite = m_Doc->Items->at(z);
ite->PoLine = clipCoords.copy(); //FIXME: try to avoid copy if FPointArray when properly shared
ite->PoLine.translate(m_Doc->currentPage()->xOffset(), m_Doc->currentPage()->yOffset());
ite->ClipEdited = true;
ite->FrameType = 3;
FPoint wh = getMaxClipF(&ite->PoLine);
ite->setWidthHeight(wh.x(),wh.y());
ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
m_Doc->AdjustItemSize(ite, true);
ite->ContourLine = ite->PoLine.copy();
ite->setItemName( tr("Group%1").arg(m_Doc->GroupCounter));
ite->setTextFlowMode(PageItem::TextFlowDisabled);
Elements.append(ite);
if ((groupStack.count() != 0) && (groupStackP.count() != 0))
groupStackP.top().append(ite);
groupStack.push(ite);
QList<PageItem*> gElements;
groupStackP.push(gElements);
gsStackMarks.push(gsStack.count());
m_Doc->GroupCounter++;
}
}
Coords = FPointArray(0);
lastPath = "";
currPath = "";
}
else if (token == "gs")
{
gsStack.push(1);
}
else if (token == "gr")
{
// #6834 : self defense against incorrectly balanced save/restore
if (gsStack.count() > 0)
gsStack.pop();
if ((groupStack.count() != 0) && (groupStackP.count() != 0))
{
if (gsStack.count() < static_cast<int>(gsStackMarks.top()))
{
PageItem *ite = groupStack.pop();
QList<PageItem*> gList = groupStackP.pop();
for (int d = 0; d < gList.count(); d++)
{
Elements.removeAll(gList.at(d));
}
m_Doc->groupObjectsToItem(ite, gList);
gsStackMarks.pop();
}
}
}
else if (token == "w")
{
ScTextStream Lw(¶ms, QIODevice::ReadOnly);
Lw >> LineW;
}
else if (token == "ld")
////////////////////////////////////////////////////////////////////////////////
/// @brief
////////////////////////////////////////////////////////////////////////////////
void EditorWindow::loadObjectVariablesData() {
//Create special mapping from materials databases
QMap<QString,QString> special_mapping;
//Parse out list of materials by class
EVDS_VARIABLE* database;
if (EVDS_System_GetDatabaseByName(system,"material",&database) == EVDS_OK) {
SIMC_LIST* entries;
EVDS_Variable_GetList(database,&entries);
SIMC_LIST_ENTRY* entry = SIMC_List_GetFirst(entries);
while (entry) {
char name[256] = { 0 };
char print_name[256] = { 0 };
char class_str[256] = { 0 };
EVDS_VARIABLE* attribute;
EVDS_VARIABLE* material = (EVDS_VARIABLE*)SIMC_List_GetData(entries,entry);
if (EVDS_Variable_GetAttribute(material,"name",&attribute) == EVDS_OK) {
EVDS_Variable_GetString(attribute,name,255,0);
}
if (EVDS_Variable_GetAttribute(material,"print",&attribute) == EVDS_OK) {
EVDS_Variable_GetString(attribute,print_name,255,0);
}
if (!print_name[0]) strcpy(print_name,name);
//Add to list
special_mapping["@materials._"] += QString(name) + "\n" + QString(print_name) + "\n";
if (EVDS_Variable_GetAttribute(material,"class",&attribute) == EVDS_OK) {
EVDS_Variable_GetString(attribute,class_str,255,0);
if (class_str[0]) {
special_mapping["@materials."+QString(class_str)] += QString(name) + "\n" + QString(print_name) + "\n";
} else {
//EVDS_BREAKPOINT();
}
}
entry = SIMC_List_GetNext(entries,entry);
}
}
//Load information about editable objects and properties
QFile xml_file(":/evds.xml");
if (!xml_file.open(QIODevice::ReadOnly)) {
return;
}
QStack<QString> currentTag;
QStack<QString> currentName;
int variable_index = 0;
QXmlStreamReader xml(&xml_file);
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement()) {
currentTag.push(xml.name().toString());
currentName.push(xml.attributes().value("name").toString());
//printf("[s] %s\n",xml.name().toAscii().data());
if (currentTag.top() == "object_vars") {
variable_index = 0;
}
if (currentTag.top() == "csection_vars") {
variable_index = 0;
}
} else if (xml.isEndElement()) {
if (currentTag.top() == "var") {
variable_index++;
}
currentTag.pop();
currentName.pop();
//printf("[e] %s\n",xml.name().toAscii().data());
} else if (xml.isCharacters() && !xml.isWhitespace()) {
if (currentTag.value(currentTag.count()-3) == "object_vars") {
QString objectType = currentName.value(currentName.count()-3);
if (objectVariables[objectType].count() <= variable_index) {
objectVariables[objectType].append(QMap<QString,QString>());
}
QString value = xml.text().toString();
QMapIterator<QString, QString> i(special_mapping);
while (i.hasNext()) {
i.next();
value.replace(i.key(),i.value());
}
objectVariables[objectType][variable_index][currentTag.top()] = value;
}
if (currentTag.value(currentTag.count()-3) == "csection_vars") {
QString csectionType = currentName.value(currentName.count()-3);
if (csectionVariables[csectionType].count() <= variable_index) {
csectionVariables[csectionType].append(QMap<QString,QString>());
}
QString value = xml.text().toString();
QMapIterator<QString, QString> i(special_mapping);
while (i.hasNext()) {
i.next();
value.replace(i.key(),i.value());
}
csectionVariables[csectionType][variable_index][currentTag.top()] = value;
}
}
}
}
bool QQuickStyledTextPrivate::parseCloseTag(const QChar *&ch, const QString &textIn, QString &textOut)
{
skipSpace(ch);
int tagStart = ch - textIn.constData();
int tagLength = 0;
while (!ch->isNull()) {
if (*ch == greaterThan) {
if (tagLength == 0)
return false;
QStringRef tag(&textIn, tagStart, tagLength);
const QChar char0 = tag.at(0);
hasNewLine = false;
if (char0 == QLatin1Char('b')) {
if (tagLength == 1)
return true;
else if (tag.at(1) == QLatin1Char('r') && tagLength == 2)
return false;
} else if (char0 == QLatin1Char('i')) {
if (tagLength == 1)
return true;
} else if (char0 == QLatin1Char('a')) {
if (tagLength == 1)
return true;
} else if (char0 == QLatin1Char('p')) {
if (tagLength == 1) {
textOut.append(QChar::LineSeparator);
hasNewLine = true;
hasSpace = true;
return false;
} else if (tag == QLatin1String("pre")) {
preFormat = false;
if (!hasNewLine)
textOut.append(QChar::LineSeparator);
hasNewLine = true;
hasSpace = true;
return true;
}
} else if (char0 == QLatin1Char('u')) {
if (tagLength == 1)
return true;
else if (tag == QLatin1String("ul")) {
if (!listStack.isEmpty()) {
listStack.pop();
if (!listStack.count())
textOut.append(QChar::LineSeparator);
}
return false;
}
} else if (char0 == QLatin1Char('h') && tagLength == 2) {
textOut.append(QChar::LineSeparator);
hasNewLine = true;
hasSpace = true;
return true;
} else if (tag == QLatin1String("font")) {
return true;
} else if (tag == QLatin1String("strong")) {
return true;
} else if (tag == QLatin1String("ol")) {
if (!listStack.isEmpty()) {
listStack.pop();
if (!listStack.count())
textOut.append(QChar::LineSeparator);
}
return false;
} else if (tag == QLatin1String("li")) {
return false;
}
return false;
} else if (!ch->isSpace()){
tagLength++;
}
++ch;
}
return false;
}
