SongList ASXParser::Load(QIODevice* device, const QString& playlist_path,
const QDir& dir) const {
// We have to load everything first so we can munge the "XML".
QByteArray data = device->readAll();
// (thanks Amarok...)
// ASX looks a lot like xml, but doesn't require tags to be case sensitive,
// meaning we have to accept things like: <Abstract>...</abstract>
// We use a dirty way to achieve this: we make all tags lower case
QRegExp ex("(<[/]?[^>]*[A-Z]+[^>]*>)");
ex.setCaseSensitivity(Qt::CaseInsensitive);
int index = 0;
while ((index = ex.indexIn(data, index)) != -1) {
data.replace(ex.cap(1).toLocal8Bit(), ex.cap(1).toLower().toLocal8Bit());
index += ex.matchedLength();
}
// Some playlists have unescaped & characters in URLs :(
ex.setPattern("(href\\s*=\\s*\")([^\"]+)\"");
index = 0;
while ((index = ex.indexIn(data, index)) != -1) {
QString url = ex.cap(2);
url.replace(QRegExp("&(?!amp;|quot;|apos;|lt;|gt;)"), "&");
QByteArray replacement = QString(ex.cap(1) + url + "\"").toLocal8Bit();
data.replace(ex.cap(0).toLocal8Bit(), replacement);
index += replacement.length();
}
QBuffer buffer(&data);
buffer.open(QIODevice::ReadOnly);
SongList ret;
QXmlStreamReader reader(&buffer);
if (!Utilities::ParseUntilElement(&reader, "asx")) {
return ret;
}
while (!reader.atEnd() && Utilities::ParseUntilElement(&reader, "entry")) {
Song song = ParseTrack(&reader, dir);
if (song.is_valid()) {
ret << song;
}
}
return ret;
}
SongList XSPFParser::Load(QIODevice* device, const QString& playlist_path,
const QDir& dir) const {
SongList ret;
QXmlStreamReader reader(device);
if (!Utilities::ParseUntilElement(&reader, "playlist") ||
!Utilities::ParseUntilElement(&reader, "trackList")) {
return ret;
}
while (!reader.atEnd() && Utilities::ParseUntilElement(&reader, "track")) {
Song song = ParseTrack(&reader, dir);
if (song.is_valid()) {
ret << song;
}
}
return ret;
}
std::vector<MusicTrack> ParseAllTracks()
{
vector<MusicTrack> tracks;
tracks.reserve( m_song.nbtrks );
try
{
size_t cnttrk = 0;
if( utils::LibWide().isLogOn() )
clog << "\t--- Parsing Tracks ---\n";
while( m_itread != m_itEoC )
{
//#1 - Find next track chunk
m_itread = DSE::FindNextChunk( m_itread, m_itEoC, DSE::eDSEChunks::trk );
if( m_itread != m_itEoC )
{
//Parse Track
tracks.push_back( ParseTrack() );
if( utils::LibWide().isLogOn() )
clog << "\t- Track " <<cnttrk <<", parsed " << tracks.back().size() <<" event(s)\n";
++cnttrk;
}
}
if( utils::LibWide().isLogOn() )
clog << "\n\n";
}
catch( std::runtime_error & e )
{
stringstream sstr;
sstr << e.what() << " Caught exception while parsing track # " <<tracks.size() <<"! ";
throw std::runtime_error( sstr.str() );
}
return std::move(tracks);
}
KmlPastebufferType Kml::ParsePasteBuffer() {
if( !wxTheClipboard->IsOpened() )
if( ! wxTheClipboard->Open() ) return KML_PASTE_INVALID;
wxTextDataObject data;
wxTheClipboard->GetData( data );
kmlText = data.GetText();
wxTheClipboard->Close();
if( kmlText.Find( _T("<kml") ) == wxNOT_FOUND ) return KML_PASTE_INVALID;
TiXmlDocument doc;
if( ! doc.Parse( kmlText.mb_str( wxConvUTF8 ), 0, TIXML_ENCODING_UTF8 ) ) {
wxLogError( wxString( doc.ErrorDesc(), wxConvUTF8 ) );
return KML_PASTE_INVALID;
}
if( 0 != strncmp( doc.RootElement()->Value(), "kml", 3 ) ) return KML_PASTE_INVALID;
TiXmlHandle docHandle( doc.RootElement() );
// We may or may not have a <document> depending on what the user copied.
TiXmlElement* placemark = docHandle.FirstChild( "Document" ).FirstChild( "Placemark" ).ToElement();
if( ! placemark ) {
placemark = docHandle.FirstChild( "Placemark" ).ToElement();
}
if( ! placemark ) {
wxString msg( _T("KML Parser found no <Placemark> tag in the KML.") );
wxLogMessage( msg );
return KML_PASTE_INVALID;
}
int pointCounter = 0;
wxString name;
for( ; placemark; placemark=placemark->NextSiblingElement() ) {
TiXmlElement* e = placemark->FirstChildElement( "name" );
if( e ) name = wxString( e->GetText(),wxConvUTF8 );
pointCounter++;
}
if( pointCounter == 1 ) {
// Is it a single waypoint?
TiXmlNode* element = docHandle.FirstChild( "Document" ).FirstChild( "Placemark" ).FirstChild( "Point" ).ToNode();
if( ! element ) element = docHandle.FirstChild( "Placemark" ).FirstChild( "Point" ).ToNode();
if( element ) return ParseOnePlacemarkPoint( element, name );
// Is it a dumb <LineString> track?
element = docHandle.FirstChild( "Document" ).FirstChild( "Placemark" ).FirstChild( "LineString" ).ToNode();
if( ! element ) element = docHandle.FirstChild( "Placemark" ).FirstChild( "LineString" ).ToNode();
if( element ) return ParseTrack( element, name );
// Is it a smart extended <gx:track> track?
element = docHandle.FirstChild( "Document" ).FirstChild( "Placemark" ).FirstChild( "gx:Track" ).ToNode();
if( ! element ) element = docHandle.FirstChild( "Placemark" ).FirstChild( "gx:Track" ).ToNode();
if( element ) return ParseTrack( element, name );
wxString msg( _T("KML Parser found a single <Placemark> in the KML, but no useable data in it.") );
wxLogMessage( msg );
return KML_PASTE_INVALID;
}
// Here we go with a full route.
parsedRoute = new Route();
bool foundPoints = false;
bool foundTrack = false;
TiXmlElement* element = docHandle.FirstChild( "Document" ).FirstChild( "name" ).ToElement();
if( element )
parsedRoute->m_RouteNameString = wxString( element->GetText(), wxConvUTF8 );
RoutePoint* rp = NULL;
placemark = docHandle.FirstChild( "Document" ).FirstChild( "Placemark" ).ToElement();
for( ; placemark; placemark=placemark->NextSiblingElement() ) {
TiXmlNode* n = placemark->FirstChild( "Point" );
if( n ) {
if( ParseOnePlacemarkPoint( n->ToElement(), name ) == KML_PASTE_WAYPOINT ) {
parsedRoute->AddPoint( new RoutePoint( parsedRoutePoint ) );
delete parsedRoutePoint;
parsedRoutePoint = 0;
foundPoints = true;
}
}
n = placemark->FirstChild( "LineString" );
if( n ) {
ParseTrack( n->ToElement(), name );
foundTrack = true;
}
n = placemark->FirstChild( "gx:Track" );
if( n ) {
ParseTrack( n->ToElement(), name );
foundTrack = true;
}
}
if( foundPoints && parsedRoute->GetnPoints() < 2 ) {
wxString msg( _T("KML Parser did not find enough <Point>s to make a route.") );
wxLogMessage( msg );
foundPoints = false;
}
if( foundPoints && ! foundTrack ) return KML_PASTE_ROUTE;
if( foundPoints && foundTrack ) return KML_PASTE_ROUTE_TRACK;
if( ! foundPoints && foundTrack ) return KML_PASTE_TRACK;
return KML_PASTE_INVALID;
}
LoadStatus_t GdbLoader::Load(void)
{
m_cOrdinal = 0;
SetProgress(g_hExp, "Loading...", 0);
size_t cOffset = sizeof(g_pGdbSignature);
size_t cFileSize = (size_t)GetFileSize();
do {
const size_t cEndOffset_tmp = __min(cOffset + sizeof(CGdbRecordHdr), cFileSize);
const char * const pRecord_tmp = GetFilePart(cOffset, cEndOffset_tmp);
if (pRecord_tmp == NULL)
return lsFailed;
const CGdbRecordHdr * const pHdr_tmp = reinterpret_cast<const CGdbRecordHdr *>(pRecord_tmp);
size_t cNextOffset = __min(cOffset + sizeof(CGdbRecordHdr) + pHdr_tmp->dwLen, cFileSize);
const char * const pRecord = GetFilePart (cOffset, cNextOffset);
if (pRecord == NULL)
return lsFailed;
const CGdbRecordHdr * const pHdr = reinterpret_cast<const CGdbRecordHdr *>(pRecord);
switch (pHdr->btType) {
case 'D': { // GDB format version.
const CGdbFormatVersion * const pVer = static_cast<const CGdbFormatVersion *>(pHdr);
switch (pVer->wdVersion) {
case 0x6B:
case 0x6C:
case 0x6D:
// AddLog(g_hExp, "GDB Format version %d.", pVer->wdVersion - 0x6B + 1);
break;
default:
// ReportText ("Format version: 0x%02X.", pVer->wdVersion);
break;
}
m_b2ndVersion = pVer->wdVersion == 0x6C;
m_b3rdVersion = pVer->wdVersion == 0x6D;
if (pVer->wdVersion > 0x6D)
AddLog(g_hExp, "File was created with an untested version of MapSource.", NULL);
break;
}
case 'A': { // MapSource version.
const CGdbMSVersion * const pVer = static_cast<const CGdbMSVersion *> (pHdr);
const char * const pRecord = GetFilePart (cOffset, cNextOffset + 10);
if (pRecord == NULL)
return lsFailed;
if (::_strnicmp (pRecord + (cNextOffset - cOffset), "MapSource", 10) == 0)
cNextOffset += 10;
break;
}
case 'W': { // Waypoint.
const CGdbWaypointHdr * const pWP = static_cast<const CGdbWaypointHdr *> (pHdr);
ParseWaypoint (pWP, cOffset, cNextOffset);
break;
}
case 'T': { // Track.
const CGdbTrackHdr * const pTrack = static_cast<const CGdbTrackHdr *> (pHdr);
ParseTrack (pTrack, cOffset, cNextOffset, cFileSize, false);
break;
}
case 'R': { // Route.
const CGdbRouteHdr * const pRoute = static_cast<const CGdbRouteHdr *> (pHdr);
ParseRoute (pRoute, cOffset, cNextOffset);
break;
}
case 'L': { // Map reference.
const CGdbMapHdr * const pMap = static_cast<const CGdbMapHdr *> (pHdr);
break;
}
case 'V': { // Tail mark and map set info.
break;
}
}
cOffset = cNextOffset;
SetProgress(g_hExp, NULL, ::MulDiv(100, cOffset, cFileSize));
} while (cOffset < cFileSize);
return lsOK;
}
