FormattedMessage FormattedMessage::parse(const QTextDocument *document)
{
FormattedMessage result;
QString text;
QTextBlock block = document->firstBlock();
bool firstParagraph = true;
while (block.isValid())
{
bool firstFragment = true;
for (QTextBlock::iterator it = block.begin(); !it.atEnd(); ++it)
{
QTextFragment fragment = it.fragment();
if (!fragment.isValid())
continue;
if (!firstParagraph && firstFragment)
text = '\n' + fragment.text();
else
text = fragment.text();
QTextCharFormat format = fragment.charFormat();
parseImages(result, text,
format.font().bold(),
format.font().italic(),
format.font().underline(),
format.foreground().color());
firstFragment = false;
}
if (firstFragment)
parseImages(result, "\n", false, false, false, QColor());
block = block.next();
firstParagraph = false;
}
return result;
}
DescriptionScene LevelModel::parseDescription (QXmlStreamReader *aXmlStreamReader)
{
assert(aXmlStreamReader);
//CrashLogger logger("LevelManager::parseDescription");
DescriptionScene result;
while (!aXmlStreamReader->atEnd() &&
!(aXmlStreamReader->isEndElement() && aXmlStreamReader->name() == "description")) {
aXmlStreamReader->readNext();
if (aXmlStreamReader->isStartElement()) {
if (aXmlStreamReader->name() == "content") {
result._description = aXmlStreamReader->readElementText();
qDebug() << "LevelManager::parseDescription " << result._description.size();
} else if (aXmlStreamReader->name() == "images") {
result._images = parseImages(aXmlStreamReader);
}
}
}
return result;
}
void Cinefacts::imagesFinished()
{
QNetworkReply *reply = static_cast<QNetworkReply*>(QObject::sender());
Movie *movie = reply->property("storage").value<Storage*>()->movie();
QList<int> infos = reply->property("infosToLoad").value<Storage*>()->infosToLoad();
reply->deleteLater();
if (!movie)
return;
if (reply->error() == QNetworkReply::NoError) {
QString msg = QString::fromUtf8(reply->readAll());
QStringList posters;
QStringList backdrops;
parseImages(msg, posters, backdrops);
if (posters.count() > 0 && infos.contains(MovieScraperInfos::Poster)) {
reply = qnam()->get(QNetworkRequest(QUrl(QString("http://www.cinefacts.de%1").arg(posters.takeFirst()))));
reply->setProperty("storage", Storage::toVariant(reply, movie));
reply->setProperty("posters", posters);
reply->setProperty("backdrops", backdrops);
reply->setProperty("infosToLoad", Storage::toVariant(reply, infos));
connect(reply, SIGNAL(finished()), this, SLOT(posterFinished()));
return;
}
if (posters.count() > 0 && infos.contains(MovieScraperInfos::Backdrop)) {
reply = qnam()->get(QNetworkRequest(QUrl(QString("http://www.cinefacts.de%1").arg(backdrops.takeFirst()))));
reply->setProperty("storage", Storage::toVariant(reply, movie));
reply->setProperty("backdrops", backdrops);
reply->setProperty("infosToLoad", Storage::toVariant(reply, infos));
connect(reply, SIGNAL(finished()), this, SLOT(backdropFinished()));
return;
}
} else {
qWarning() << "Network Error" << reply->errorString();
}
movie->controller()->scraperLoadDone(this);
}
// the above mentioned overloaded method -- file syntax is derived
// from MIL-STD-2500B release 2
TSMWarning *parseFile(NITF_2_1_ISD *isd) throw (TSMError)
{
TSMError err;
TSMWarning *warn = new TSMWarning(TSMWarning::UNKNOWN_WARNING, "", "");
char parseBuff [13];
if (!buff) // fillBuff() failed or somebody called me before calling fillBuff() -- should never get here
{
err.setTSMError (TSMError::INVALID_USE,
"No ISD data buffer: fillBuff failed",
"parseFile");
throw (err);
}
char pbuff[4096]; // parser buffer
int fl, // file length
hl; // file header length. Required to locate
// beginning of first image data.
// locations and field lengths of the FL, HL, and NUMI fields are
// all at fixed offsets in the 2.1 header. These values are taken
// from MIL-STD-2500B Notice 2
const int FLOFFSET = 342;
const int FLLEN = 12;
const int HLOFFSET = 354;
const int HLLEN = 6;
const int NUMIOFFSET = 360;
const int NUMILEN = 3;
memcpy (parseBuff, &buff[FLOFFSET], FLLEN);
parseBuff[FLLEN] = '\0';
fl = atoi (parseBuff);
if (statbuf.st_size != fl)
warn->setTSMWarning( TSMWarning::UNKNOWN_WARNING,
"File length field does not match actual file length",
"parseFile(nitf2.1)");
memcpy (pbuff, &buff[HLOFFSET], 6); pbuff[6] = '\0';
hl = atoi(pbuff);
if (statbuf.st_size < hl)
{
// choke
err.setTSMError(TSMError::DATA_NOT_AVAILABLE,
"ISD file smaller than indicated header length",
"parseFile(nitf2.1)");
throw err;
}
memcpy (parseBuff, &buff[HLOFFSET],HLLEN );
parseBuff[HLLEN] = '\0';
hl = atoi (parseBuff);
// Copy the file header
isd->fileHeader.assign (buff, hl);
unsigned int des_offset = hl; // This value will be used to locate
// the DES data in the 2.1 file
//////////////////////////////////////////////////////////////////
//////// This section goes through the 2.1 file header /////
//////// accumulating size information for the various /////
//////// segments of the file. Althought at the present /////
//////// time only image info, DES info and User Defined /////
//////// Header data (tre) are required for the class, all /////
//////// of the section length info is retained for /////
//////// possible future use. /////
//////////////////////////////////////////////////////////////////
int seg_index;
int seg_offset = NUMIOFFSET;
////////////////////////////////////////////////
// process 2.1 image segments length info /////
////////////////////////////////////////////////
memcpy (parseBuff, &buff[seg_offset],NUMILEN );
parseBuff[NUMILEN] = '\0';
int NUMI = atoi (parseBuff);
// std::cout << "**** NUMI = " << NUMI << '\n';
isd->numImages = NUMI;
std::vector <int> imagehdrlengths (NUMI);
std::vector <int> imagelengths (NUMI);
seg_offset = seg_offset + 3;
for (seg_index = 0; seg_index < isd->numImages; seg_index++)
{
memcpy (parseBuff, &buff[seg_offset], 6); parseBuff[6] = '\0';
imagehdrlengths.at(seg_index) = atoi (parseBuff);
des_offset += imagehdrlengths.at(seg_index);
seg_offset += 6;
memcpy (parseBuff, &buff[seg_offset], 10); parseBuff[10] = '\0';
imagelengths[seg_index] = atoi (parseBuff);
des_offset += imagelengths[seg_index];
seg_offset += 10;
}
// Because the number of entries in each of the 2.1 header/data
// segment length fields varies as the number of segments there are
// no fixed offsets.
//////////////////////////////////////////////////
//// process 2.1 Graphic segments length info ////
//////////////////////////////////////////////////
memcpy (parseBuff, &buff[seg_offset], 3); parseBuff[3] = '\0';
int NUMS = atoi (parseBuff);
// std::cout << "**** NUMS = " << NUMS << '\n';
seg_offset += 3;
if (NUMS > 0)
{
std::vector <int> numShdrlengths (NUMS);
std::vector <int> numSlengths (NUMS);
for (seg_index = 0; seg_index < NUMS; seg_index++)
{
memcpy (parseBuff, &buff[seg_offset], 4); parseBuff[4] = '\0';
numShdrlengths.at (seg_index) = atoi (parseBuff);
des_offset += numShdrlengths.at (seg_index);
seg_offset += 4;
memcpy (parseBuff, &buff[seg_offset], 3); parseBuff[3] = '\0';
numSlengths.at (seg_index) = atoi (parseBuff);
seg_offset += 6;
}
}
// There is a 3 space field called NUMX whixh is not currently used
// by the 2500B standard
seg_offset += 3;
////////////////////////////////////////////////////////////
//// process 2.1 Text Segments length info ////
/////////////////////////////////////////////////////////////
memcpy (parseBuff, &buff[seg_offset], 3); parseBuff[3] = '\0';
int NUMT = atoi (parseBuff);
// std::cout << "**** NUMT = " << NUMT << '\n';
seg_offset += 3;
if (NUMT > 0)
{
std::vector <int> numThdrlengths (NUMT);
std::vector <int> numTlengths (NUMT);
for (int t_index = 0; t_index < NUMT; t_index++)
{
memcpy (parseBuff, &buff[seg_offset], 4); parseBuff[4] = '\0';
numThdrlengths [t_index] = atoi (parseBuff);
des_offset += numThdrlengths [t_index];
seg_offset += 4;
memcpy (parseBuff, &buff[seg_offset], 5); parseBuff[5] = '\0';
numTlengths [t_index] = atoi (parseBuff);
des_offset += numTlengths [t_index];
seg_offset += 5;
}
}
////////////////////////////////////////////////////////////
//// process 2.1 Data Extension Segments length info ////
////////////////////////////////////////////////////////////
memcpy (parseBuff, &buff[seg_offset], 3); parseBuff[3] = '\0';
int NUMD = atoi (parseBuff);
// std::cout << "**** NUMD = " << NUMD << '\n';
isd->numDESs = NUMD;
seg_offset += 3;
std::vector <int> Dhdrlengths (NUMD);
std::vector <int> Dlengths (NUMD);
if (NUMD > 0)
{
for (seg_index = 0; seg_index < NUMD; seg_index++)
{
memcpy (parseBuff, &buff[seg_offset], 4); parseBuff[4] = '\0';
Dhdrlengths [seg_index] = atoi (parseBuff);
seg_offset += 4;
memcpy (parseBuff, &buff[seg_offset], 9); parseBuff[9] = '\0';
Dlengths [seg_index] = atoi (parseBuff);
seg_offset += 9;
}
}
////////////////////////////////////////////////////////////////
//// process 2.1 Reserved Extension Segments length info ////
////////////////////////////////////////////////////////////////
memcpy (parseBuff, &buff[seg_offset], 3); parseBuff[3] = '\0';
int numR = atoi (parseBuff);
seg_offset += 3;
std::vector <int> numRhdrlengths (numR);
std::vector <int> numRlengths (numR);
for (seg_index = 0; seg_index < numR; seg_index++)
{
memcpy (parseBuff, &buff[seg_offset], 4); parseBuff[4] = '\0';
numRhdrlengths [seg_index] = atoi (parseBuff);
seg_offset += 4;
memcpy (parseBuff, &buff[seg_offset], 7); parseBuff[7] = '\0';
numRlengths [seg_index] = atoi (parseBuff);
seg_offset += 7;
}
////////////////////////////////////////////////////////////
//// process 2.1 UDHD/XHD (file tre) info ////
////////////////////////////////////////////////////////////
// this 5 byte adjustment is also different from the book to the data
seg_offset += 5;
// std::cout << "<<<<< seg_offset " << seg_offset << '\n';
memcpy (parseBuff, &buff[seg_offset], 5); parseBuff[5] = '\0';
int lenUDHD = atoi (parseBuff);
seg_offset += 5;
seg_offset += 3; // added to get past currently unused UDHOFL field
// store file header UD tre's in string
std::string UDHD;
if ((lenUDHD - 3) > 0)
UDHD.assign (&buff[seg_offset], lenUDHD - 3);
seg_offset += lenUDHD - 3 ;
memcpy (parseBuff, &buff[seg_offset], 5); parseBuff[5] = '\0';
int XHDL = atoi (parseBuff);
seg_offset += 5;
// store file header X UD tre's in string
std::string XHD;
if (XHDL > 0)
XHD.assign (&buff[seg_offset], XHDL);
std::string HD;
if ((XHDL + lenUDHD - 3) > 0)
HD.assign (UDHD + XHD);
int udidl = XHDL + lenUDHD - 3;
// if any file tre data parse it
if (udidl > 0)
parseTRE (udidl, HD, &isd->numTREs, &(isd->fileTREs));
if (NUMI > 0)
parseImages(isd, hl, imagehdrlengths, imagelengths);
if (NUMD > 0)
parseDES(isd, des_offset, Dhdrlengths, Dlengths);
return warn;
};
///////////////////////////////////////////////////////////////////////////
// This method parses the data in the file header to derive sizes and
// numbers of each of the file component segments. It also processes
// any file tre's. This function is derived from information in
// MIL-STD-2500A, release 3
//
// this function will have to be overloaded for NITF21 isd's
//////////////////////////////////////////////////////////////////////////
TSMWarning *parseFile (NITF_2_0_ISD *isd) throw (TSMError)
{
TSMError err;
TSMWarning *warning = new TSMWarning (TSMWarning::UNKNOWN_WARNING, "", "");
if (!buff) // fillBuff failed -- should never get here
{
err.setTSMError (TSMError::INVALID_USE,
"No ISD data buffer: fillBuff failed",
"parseFile");
throw (err);
}
char pbuff[4096]; // parser buffer
int fl, // file length
hl; // file header length
int crypt_offset;
int class_offset = 119; // location of classification indicator in
// file header
// check for conditional fields
// if file is classified at any level the class info is 40 bytes longer
if (buff[class_offset] == 'U')
crypt_offset = 296;
else
crypt_offset = 336;
// location of file length field in 2.0 file
int fl_offset = crypt_offset + 46;
memcpy (pbuff, &buff[fl_offset], 12); pbuff[12] = '\0';
fl = atoi(pbuff);
if (statbuf.st_size != fl)
warning->setTSMWarning( TSMWarning::UNKNOWN_WARNING,
"File length field does not match actual file length",
"parseFile(nitf2.0)");
// get 2.0 file header length
int hl_offset = fl_offset + 12;
memcpy (pbuff, &buff[hl_offset], 6); pbuff[6] = '\0';
hl = atoi(pbuff);
if (statbuf.st_size < hl)
{
// choke
err.setTSMError(TSMError::DATA_NOT_AVAILABLE,
"ISD file smaller than indicated header length",
"parseFile(nitf2.0)");
throw err;
}
// Copy the file header
isd->fileHeader.assign (buff, hl);
////////////////////////////////////////////////////////////////
////// This section goes through the file 2.0 header /////
////// accumulating size information for the various /////
////// segments of the file. Althought at the present /////
////// time only image info, DES info and User Defined /////
////// Header data (tre) are required for the class, all /////
////// of the section length info is retained for /////
////// possible future use. /////
////////////////////////////////////////////////////////////////
int seg_index;
unsigned int des_offset = hl; // This value will be used to point to
// the location in the 2.0 file of the
// DES data
////////////////////////////////////////////
// process image segments length info /////
////////////////////////////////////////////
int numi_offset = hl_offset + 6;
memcpy (pbuff, &buff[numi_offset], 3); pbuff[3] = '\0';
int NUMI = atoi (pbuff);
isd->numImages = NUMI;
// std::cout << "num images = " << isd->numImages << '\n';
int seg_offset = numi_offset + 3;
if (NUMI > 0)
{
std::vector <int> imagehdrlengths (NUMI);
std::vector <int> imagelengths (NUMI);
for (seg_index = 0; seg_index < isd->numImages; seg_index++)
{
memcpy (pbuff, &buff[seg_offset], 6); pbuff[6] = '\0';
imagehdrlengths.at(seg_index) = atoi (pbuff);
des_offset += imagehdrlengths.at(seg_index);
seg_offset += 6;
memcpy (pbuff, &buff[seg_offset], 10); pbuff[10] = '\0';
imagelengths[seg_index] = atoi (pbuff);
des_offset += imagelengths[seg_index];
seg_offset += 10;
}
//////////////////////////////////////////////////
//// process 2.0 Symbols segments length info ////
//////////////////////////////////////////////////
memcpy (pbuff, &buff[seg_offset], 3); pbuff[3] = '\0';
int NUMS = atoi (pbuff);
seg_offset += 3;
if (NUMS > 0)
{
std::vector <int> numshdrlengths (NUMS);
std::vector <int> numslengths (NUMS);
for (seg_index = 0; seg_index < NUMS; seg_index++)
{
memcpy (pbuff, &buff[seg_offset], 4); pbuff[4] = '\0';
numshdrlengths.at (seg_index) = atoi (pbuff);
des_offset += numshdrlengths.at (seg_index);
seg_offset += 4;
memcpy (pbuff, &buff[seg_offset], 6); pbuff[6] = '\0';
numslengths.at (seg_index) = atoi (pbuff);
des_offset += numslengths.at (seg_index);
seg_offset += 6;
}
}
///////////////////////////////////////////////////
//// process 2.0 Label segments length info ////
///////////////////////////////////////////////////
memcpy (pbuff, &buff[seg_offset], 3); pbuff[3] = '\0';
int NUML = atoi (pbuff);
seg_offset += 3;
if (NUML > 0)
{
std::vector <int> numLhdrlengths (NUML);
std::vector <int> numLlengths (NUML);
for (seg_index = 0; seg_index < NUML; seg_index++)
{
memcpy (pbuff, &buff[seg_offset], 4); pbuff[4] = '\0';
numLhdrlengths.at (seg_index) = atoi (pbuff);
des_offset += numLhdrlengths.at (seg_index);
seg_offset += 4;
memcpy (pbuff, &buff[seg_offset], 3); pbuff[3] = '\0';
numLlengths.at (seg_index) = atoi (pbuff);
des_offset += numLlengths.at (seg_index);
seg_offset += 3;
}
}
////////////////////////////////////////////////////////////
//// process 2.0 Text Segments length info ////
////////////////////////////////////////////////////////////
memcpy (pbuff, &buff[seg_offset], 3); pbuff[3] = '\0';
int NUMT = atoi (pbuff);
seg_offset += 3;
if (NUMT > 0 )
{
std::vector <int> numThdrlengths (NUMT);
std::vector <int> numTlengths (NUMT);
for (int t_index = 0; t_index < NUMT; t_index++)
{
memcpy (pbuff, &buff[seg_offset], 4); pbuff[4] = '\0';
numThdrlengths [t_index] = atoi (pbuff);
des_offset += numThdrlengths [t_index];
seg_offset += 4;
memcpy (pbuff, &buff[seg_offset], 5); pbuff[5] = '\0';
numTlengths [t_index] = atoi (pbuff);
des_offset += numTlengths [t_index];
seg_offset += 5;
}
}
////////////////////////////////////////////////////////////
//// process 2.0 Data Extension Segments length info ////
////////////////////////////////////////////////////////////
memcpy (pbuff, &buff[seg_offset], 3); pbuff[3] = '\0';
int NUMD = atoi (pbuff);
seg_offset += 3;
std::vector <int> DEShdrlengths (NUMD);
std::vector <int> DESlengths (NUMD);
if (NUMD > 0)
for (seg_index = 0; seg_index < NUMD; seg_index++)
{
memcpy (pbuff, &buff[seg_offset], 4); pbuff[4] = '\0';
DEShdrlengths [seg_index] = atoi (pbuff);
seg_offset += 4;
memcpy (pbuff, &buff[seg_offset], 9); pbuff[9] = '\0';
DESlengths [seg_index] = atoi (pbuff);
seg_offset += 9;
}
/////////////////////////////////////////////////////////////
//// process 2.0 Reserved Extension Segments length info ////
/////////////////////////////////////////////////////////////
memcpy (pbuff, &buff[seg_offset], 3); pbuff[3] = '\0';
int numR = atoi (pbuff);
seg_offset += 3;
std::vector <int> numRhdrlengths (numR);
std::vector <int> numRlengths (numR);
for (seg_index = 0; seg_index < numR; seg_index++)
{
memcpy (pbuff, &buff[seg_offset], 4); pbuff[4] = '\0';
numRhdrlengths [seg_index] = atoi (pbuff);
seg_offset += 4;
memcpy (pbuff, &buff[seg_offset], 7); pbuff[7] = '\0';
numRlengths [seg_index] = atoi (pbuff);
seg_offset += 7;
}
////////////////////////////////////////////////////////////
//// process 2.0 UDHD/XHD info ////
////////////////////////////////////////////////////////////
//std::cout << "seg_offset " << seg_offset << '\n';
memcpy (pbuff, &buff[seg_offset], 5); pbuff[5] = '\0';
int lenUDHD = atoi (pbuff);
seg_offset += 5;
seg_offset += 3; // added to get past currently unused UDHOFL field
// store file header UD tre's in string
std::string UDHD;
if (lenUDHD > 0)
UDHD.assign (&buff[seg_offset], lenUDHD);
seg_offset += lenUDHD -3;
memcpy (pbuff, &buff[seg_offset], 5); pbuff[5] = '\0';
int lenXHD = atoi (pbuff);
seg_offset += 5;
// store file header UD tre's in string
std::string XHD;
if (lenXHD > 0)
XHD.assign (&buff[seg_offset], lenXHD);
std::string HD = UDHD + XHD;
unsigned int treLen = lenUDHD + lenXHD;
// parse file tre's
if (treLen)
parseTRE (treLen, HD, &isd->numTREs, &isd->fileTREs);
////////////////////////////////////////////
/////// End of fileheader code ////////////
////////////////////////////////////////////
seg_offset += treLen; // cue up to begining of first image group
if (seg_offset != hl)
{
std::cout << "Parser error in file header -- hl = " << hl << " offset = " << seg_offset << '\n';
exit (666);
}
/////// Begin 2.0 image sub-header parsing
if (NUMI > 0)
parseImages (isd, hl, imagehdrlengths, imagelengths);
if (NUMD > 0)
parseDES(isd, des_offset, DEShdrlengths, DESlengths);
}
return warning;
}
