bool DataBus::PacketHeader::parse(const QByteArray &packetHeaderData,
const int startIndex,
PacketHeader *packetHeader)
{
// Check input parameters
if ((startIndex < 0) ||
(startIndex >= packetHeaderData.size()))
{
// Error, invalid start index
return false;
}
if ((packetHeaderData.size() - startIndex) < 6)
{
// Error, data is not big enough
return false;
}
if (packetHeader == 0)
{
// Error, null pointer
return false;
}
// Parse header checksum
quint8 headerChecksum = (quint8)packetHeaderData.at(startIndex + 5);
bool ok = false;
quint8 calculatedChecksum = DataBus::calculateChecksum(packetHeaderData, startIndex, 5, &ok);
if ((ok == false) ||
(headerChecksum != calculatedChecksum))
{
// Error, invalid checksum
return false;
}
// Parse source
quint8 source = (quint8)packetHeaderData.at(startIndex + 0);
// Parse destination
quint8 destination = (quint8)packetHeaderData.at(startIndex + 1);
// Parse packet type
quint8 packetTypeValue = (quint8)packetHeaderData.at(startIndex + 2);
if (packetTypeValue > PacketType_ExecuteClientMethodResponse)
{
// Error, invalid packet type value
return false;
}
PacketType packetType = (PacketType)packetTypeValue;
// Parse packet ID
quint8 packetId = (quint8)packetHeaderData.at(startIndex + 3);
// Parse payload size
quint8 payloadSize = (quint8)packetHeaderData.at(startIndex + 4);
// Save values
packetHeader->setSource(source);
packetHeader->setDestination(destination);
packetHeader->setPacketType(packetType);
packetHeader->setPacketId(packetId);
packetHeader->setPayloadSize(payloadSize);
// Success
return true;
}
QList<QNetworkProxy> macQueryInternal(const QNetworkProxyQuery &query)
{
QList<QNetworkProxy> result;
// obtain a dictionary to the proxy settings:
CFDictionaryRef dict = SCDynamicStoreCopyProxies(NULL);
if (!dict) {
qWarning("QNetworkProxyFactory::systemProxyForQuery: SCDynamicStoreCopyProxies returned NULL");
return result; // failed
}
if (isHostExcluded(dict, query.peerHostName())) {
CFRelease(dict);
return result; // no proxy for this host
}
// is there a PAC enabled? If so, use it first.
CFNumberRef pacEnabled;
if ((pacEnabled = (CFNumberRef)CFDictionaryGetValue(dict, kSCPropNetProxiesProxyAutoConfigEnable))) {
int enabled;
if (CFNumberGetValue(pacEnabled, kCFNumberIntType, &enabled) && enabled) {
// PAC is enabled
// kSCPropNetProxiesProxyAutoConfigURLString returns the URL string
// as entered in the system proxy configuration dialog
CFStringRef pacLocationSetting = (CFStringRef)CFDictionaryGetValue(dict, kSCPropNetProxiesProxyAutoConfigURLString);
QCFType<CFStringRef> cfPacLocation = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, pacLocationSetting, NULL, NULL,
kCFStringEncodingUTF8);
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
QCFType<CFDataRef> pacData;
QCFType<CFURLRef> pacUrl = CFURLCreateWithString(kCFAllocatorDefault, cfPacLocation, NULL);
if (!pacUrl) {
qWarning("Invalid PAC URL \"%s\"", qPrintable(QCFString::toQString(cfPacLocation)));
return result;
}
SInt32 errorCode;
if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, pacUrl, &pacData, NULL, NULL, &errorCode)) {
QString pacLocation = QCFString::toQString(cfPacLocation);
qWarning("Unable to get the PAC script at \"%s\" (%s)", qPrintable(pacLocation), cfurlErrorDescription(errorCode));
return result;
}
if (!pacData) {
qWarning("\"%s\" returned an empty PAC script", qPrintable(QCFString::toQString(cfPacLocation)));
return result;
}
QCFType<CFStringRef> pacScript = CFStringCreateFromExternalRepresentation(kCFAllocatorDefault, pacData, kCFStringEncodingISOLatin1);
if (!pacScript) {
// This should never happen, but the documentation says it may return NULL if there was a problem creating the object.
QString pacLocation = QCFString::toQString(cfPacLocation);
qWarning("Unable to read the PAC script at \"%s\"", qPrintable(pacLocation));
return result;
}
QByteArray encodedURL = query.url().toEncoded(); // converted to UTF-8
if (encodedURL.isEmpty()) {
return result; // Invalid URL, abort
}
QCFType<CFURLRef> targetURL = CFURLCreateWithBytes(kCFAllocatorDefault, (UInt8*)encodedURL.data(), encodedURL.size(), kCFStringEncodingUTF8, NULL);
if (!targetURL) {
return result; // URL creation problem, abort
}
QCFType<CFErrorRef> pacError;
QCFType<CFArrayRef> proxies = CFNetworkCopyProxiesForAutoConfigurationScript(pacScript, targetURL, &pacError);
if (!proxies) {
QString pacLocation = QCFString::toQString(cfPacLocation);
QCFType<CFStringRef> pacErrorDescription = CFErrorCopyDescription(pacError);
qWarning("Execution of PAC script at \"%s\" failed: %s", qPrintable(pacLocation), qPrintable(QCFString::toQString(pacErrorDescription)));
return result;
}
CFIndex size = CFArrayGetCount(proxies);
for (CFIndex i = 0; i < size; ++i) {
CFDictionaryRef proxy = (CFDictionaryRef)CFArrayGetValueAtIndex(proxies, i);
result << proxyFromDictionary(proxy);
}
return result;
} else {
QString pacLocation = QCFString::toQString(cfPacLocation);
qWarning("Mac system proxy: PAC script at \"%s\" not handled", qPrintable(pacLocation));
}
}
}
// no PAC, decide which proxy we're looking for based on the query
bool isHttps = false;
QString protocol = query.protocolTag().toLower();
// try the protocol-specific proxy
QNetworkProxy protocolSpecificProxy;
if (protocol == QLatin1String("ftp")) {
protocolSpecificProxy =
proxyFromDictionary(dict, QNetworkProxy::FtpCachingProxy,
kSCPropNetProxiesFTPEnable,
kSCPropNetProxiesFTPProxy,
kSCPropNetProxiesFTPPort);
} else if (protocol == QLatin1String("http")) {
protocolSpecificProxy =
proxyFromDictionary(dict, QNetworkProxy::HttpProxy,
kSCPropNetProxiesHTTPEnable,
kSCPropNetProxiesHTTPProxy,
kSCPropNetProxiesHTTPPort);
} else if (protocol == QLatin1String("https")) {
isHttps = true;
protocolSpecificProxy =
proxyFromDictionary(dict, QNetworkProxy::HttpProxy,
kSCPropNetProxiesHTTPSEnable,
kSCPropNetProxiesHTTPSProxy,
kSCPropNetProxiesHTTPSPort);
}
if (protocolSpecificProxy.type() != QNetworkProxy::DefaultProxy)
result << protocolSpecificProxy;
// let's add SOCKSv5 if present too
QNetworkProxy socks5 = proxyFromDictionary(dict, QNetworkProxy::Socks5Proxy,
kSCPropNetProxiesSOCKSEnable,
kSCPropNetProxiesSOCKSProxy,
kSCPropNetProxiesSOCKSPort);
if (socks5.type() != QNetworkProxy::DefaultProxy)
result << socks5;
// let's add the HTTPS proxy if present (and if we haven't added
// yet)
if (!isHttps) {
QNetworkProxy https = proxyFromDictionary(dict, QNetworkProxy::HttpProxy,
kSCPropNetProxiesHTTPSEnable,
kSCPropNetProxiesHTTPSProxy,
kSCPropNetProxiesHTTPSPort);
if (https.type() != QNetworkProxy::DefaultProxy && https != protocolSpecificProxy)
result << https;
}
CFRelease(dict);
return result;
}
//! [8]
bool ByteArrayClassPropertyIterator::hasNext() const
{
QByteArray *ba = qscriptvalue_cast<QByteArray*>(object().data());
return m_index < ba->size();
}
void ByteArrayClassPropertyIterator::toBack()
{
QByteArray *ba = qscriptvalue_cast<QByteArray*>(object().data());
m_index = ba->size();
m_last = -1;
}
qint64 KoStore::write(const QByteArray& data)
{
return write(data.data(), data.size()); // see below
}
//*****************************************************************************
mlMainWindow::mlMainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::mlMainWindow),
uniConverter(0) {
ui->setupUi(this);
//-------------------------------------------------------------------------
// Load the mapping file
QByteArray map;
QFile mfile(":/maps/maps/mollana-urdu.tec");
if( mfile.open( QIODevice::ReadOnly ) ) {
qDebug() << "Internal Urdu mapping file loaded...";
map = mfile.readAll();
mfile.close();
qDebug() << "Map size: " << map.size() << "";
} else {
qDebug() << "Unable to open Internal Urdu mapping file for reading...\n";
//raise exception
return;
}
//-------------------------------------------------------------------------
// Create the converter
uniConverter = new TECkitConverter( map );
if( !uniConverter->isValid() ) {
qDebug() << "Unable to create Unicode TECkit converter...";
//raise exception
return;
}
//-------------------------------------------------------------------------
// Toolbars
ui->mainToolBar->addAction( ui->actionNew );
ui->mainToolBar->addAction( ui->actionOpen );
ui->mainToolBar->addAction( ui->actionSave );
ui->mainToolBar->addSeparator();
ui->mainToolBar->addAction( ui->actionUndo );
ui->mainToolBar->addAction( ui->actionRedo );
ui->mainToolBar->addSeparator();
ui->mainToolBar->addAction( ui->actionCopy );
ui->mainToolBar->addAction( ui->actionCut );
ui->mainToolBar->addAction( ui->actionPaste );
ui->mainToolBar->addSeparator();
ui->mainToolBar->addAction( ui->actionUnicodeViewFont );
ui->mainToolBar->addAction( ui->actionWordWrap );
ui->mainToolBar->addSeparator();
//-------------------------------------------------------------------------
// Signal/Slots
connect(ui->actionNew, SIGNAL(triggered()),
this, SLOT(newFile()) );
connect(ui->actionOpen, SIGNAL(triggered()),
this, SLOT(open()) );
connect(ui->actionSave, SIGNAL(triggered()),
this, SLOT(save()) );
connect(ui->actionSaveAs, SIGNAL(triggered()),
this, SLOT(saveAs()) );
connect(ui->actionQuit, SIGNAL(triggered()),
this, SLOT(close()) );
connect(ui->actionSelectAll,SIGNAL(triggered()),
ui->tbxEditor, SLOT(selectAll()) );
connect(ui->actionEditorFont,
SIGNAL(triggered()),
this, SLOT(editorFontChanged()) );
connect(ui->actionUnicodeViewFont,
SIGNAL(triggered()),
this, SLOT(unicodeFontChanged()) );
connect(ui->actionAbout, SIGNAL(triggered()),
this, SLOT(about()) );
connect(ui->tbxEditor->document(),
SIGNAL(contentsChanged()),
this, SLOT(documentModified()) );
// Copy, Cut & Paste
connect(ui->actionCut, SIGNAL(triggered()),
ui->tbxEditor, SLOT(cut()) );
connect(ui->actionCopy, SIGNAL(triggered()),
ui->tbxEditor, SLOT(copy()) );
connect(ui->actionPaste, SIGNAL(triggered()),
ui->tbxEditor, SLOT(paste()) );
connect(ui->tbxEditor, SIGNAL(copyAvailable(bool)),
ui->actionCopy, SLOT(setEnabled(bool)) );
connect(ui->tbxEditor, SIGNAL(copyAvailable(bool)),
ui->actionCut, SLOT(setEnabled(bool)) );
// Undo & Redo
connect(ui->actionUndo, SIGNAL(triggered()),
ui->tbxEditor, SLOT(undo()) );
connect(ui->actionCopy, SIGNAL(triggered()),
ui->tbxEditor, SLOT(redo()) );
connect(ui->tbxEditor, SIGNAL(undoAvailable(bool)),
ui->actionUndo, SLOT(setEnabled(bool)) );
connect(ui->tbxEditor, SIGNAL(redoAvailable(bool)),
ui->actionRedo, SLOT(setEnabled(bool)) );
connect(ui->actionWordWrap, SIGNAL(toggled(bool)),
this, SLOT(wordWrapChanged(bool)) );
connect(ui->actionUnicodeOutput,
SIGNAL(toggled(bool)),
ui->dckUnicodeOutput,
SLOT(setVisible(bool)) );
connect(ui->tbxEditor, SIGNAL(textChanged()),
this, SLOT(translateText()) );
//-------------------------------------------------------------------------
QFont f = ui->tbxUnicodeView->font();
f.setStyleStrategy(QFont::PreferAntialias);
ui->tbxUnicodeView->setFont(f);
//-------------------------------------------------------------------------
// Start with a new file
newFile();
}
int UPNPSubscription::SendSubscribeRequest(const QString &callback,
const QString &usn,
const QUrl &url,
const QString &path,
const QString &uuidin,
QString &uuidout)
{
QString host = url.host();
int port = url.port();
QByteArray sub;
QTextStream data(&sub);
data.setCodec(QTextCodec::codecForName("UTF-8"));
// N.B. Play On needs an extra space between SUBSCRIBE and path...
data << QString("SUBSCRIBE %1 HTTP/1.1\r\n").arg(path);
data << QString("HOST: %1:%2\r\n").arg(host).arg(QString::number(port));
if (uuidin.isEmpty()) // new subscription
{
data << QString("CALLBACK: <%1%2>\r\n")
.arg(callback).arg(usn);
data << "NT: upnp:event\r\n";
}
else // renewal
data << QString("SID: uuid:%1\r\n").arg(uuidin);
data << QString("TIMEOUT: Second-%1\r\n").arg(SUBSCRIPTION_TIME);
data << "\r\n";
data.flush();
LOG(VB_UPNP, LOG_DEBUG, "\n\n" + sub);
MSocketDevice *sockdev = new MSocketDevice(MSocketDevice::Stream);
BufferedSocketDevice *sock = new BufferedSocketDevice(sockdev);
sockdev->setBlocking(true);
QString uuid;
QString timeout;
uint result = 0;
if (sock->Connect(QHostAddress(host), port))
{
if (sock->WriteBlockDirect(sub.constData(), sub.size()) != -1)
{
bool ok = false;
QString line = sock->ReadLine(MAX_WAIT);
while (!line.isEmpty())
{
LOG(VB_UPNP, LOG_DEBUG, line);
if (line.contains("HTTP/1.1 200 OK", Qt::CaseInsensitive))
ok = true;
if (line.startsWith("SID:", Qt::CaseInsensitive))
uuid = line.mid(4).trimmed().mid(5).trimmed();
if (line.startsWith("TIMEOUT:", Qt::CaseInsensitive))
timeout = line.mid(8).trimmed().mid(7).trimmed();
if (ok && !uuid.isEmpty() && !timeout.isEmpty())
break;
line = sock->ReadLine(MAX_WAIT);
}
if (ok && !uuid.isEmpty() && !timeout.isEmpty())
{
uuidout = uuid;
result = timeout.toUInt();
}
else
{
LOG(VB_GENERAL, LOG_ERR,
QString("Failed to subscribe to %1").arg(usn));
}
}
else
{
LOG(VB_GENERAL, LOG_ERR, QString("Socket write error for %1:%2")
.arg(host).arg(port));
}
sock->Close();
}
else
{
LOG(VB_GENERAL, LOG_ERR, QString("Failed to open socket for %1:%2")
.arg(host).arg(port));
}
delete sock;
delete sockdev;
return result;
}
void ExecuteFilter::readStandardOutput()
{
QByteArray data = m_process->readAllStandardOutput();
MessageManager::write(QTextCodec::codecForLocale()->toUnicode(data.constData(), data.size(),
&m_stdoutState));
}
QByteArray GameCFGWidget::getFullConfig() const
{
QList<QByteArray> bcfg;
int mapgen = pMapContainer->get_mapgen();
if (Scripts->currentIndex() > 0)
{
bcfg << QString("escript Scripts/Multiplayer/%1.lua").arg(Scripts->itemData(Scripts->currentIndex(), GameStyleModel::ScriptRole).toString()).toUtf8();
}
QString currentMap = pMapContainer->getCurrentMap();
if (currentMap.size() > 0)
{
bcfg << QString("emap " + currentMap).toUtf8();
// engine should figure it out on its own
// if(pMapContainer->getCurrentIsMission())
// bcfg << QString("escript Maps/%1/map.lua").arg(currentMap).toUtf8();
}
bcfg << QString("etheme " + pMapContainer->getCurrentTheme()).toUtf8();
bcfg << QString("eseed " + pMapContainer->getCurrentSeed()).toUtf8();
bcfg << QString("e$gmflags %1").arg(getGameFlags()).toUtf8();
bcfg << QString("e$damagepct %1").arg(schemeData(26).toInt()).toUtf8();
bcfg << QString("e$turntime %1").arg(schemeData(27).toInt() * 1000).toUtf8();
bcfg << QString("e$sd_turns %1").arg(schemeData(29).toInt()).toUtf8();
bcfg << QString("e$casefreq %1").arg(schemeData(30).toInt()).toUtf8();
bcfg << QString("e$minestime %1").arg(schemeData(31).toInt() * 1000).toUtf8();
bcfg << QString("e$minesnum %1").arg(schemeData(32).toInt()).toUtf8();
bcfg << QString("e$minedudpct %1").arg(schemeData(33).toInt()).toUtf8();
bcfg << QString("e$explosives %1").arg(schemeData(34).toInt()).toUtf8();
bcfg << QString("e$airmines %1").arg(schemeData(35).toInt()).toUtf8();
bcfg << QString("e$healthprob %1").arg(schemeData(36).toInt()).toUtf8();
bcfg << QString("e$hcaseamount %1").arg(schemeData(37).toInt()).toUtf8();
bcfg << QString("e$waterrise %1").arg(schemeData(38).toInt()).toUtf8();
bcfg << QString("e$healthdec %1").arg(schemeData(39).toInt()).toUtf8();
bcfg << QString("e$ropepct %1").arg(schemeData(40).toInt()).toUtf8();
bcfg << QString("e$getawaytime %1").arg(schemeData(41).toInt()).toUtf8();
bcfg << QString("e$worldedge %1").arg(schemeData(42).toInt()).toUtf8();
bcfg << QString("e$template_filter %1").arg(pMapContainer->getTemplateFilter()).toUtf8();
bcfg << QString("e$feature_size %1").arg(pMapContainer->getFeatureSize()).toUtf8();
bcfg << QString("e$mapgen %1").arg(mapgen).toUtf8();
if(!schemeData(43).isNull())
bcfg << QString("e$scriptparam %1").arg(schemeData(43).toString()).toUtf8();
switch (mapgen)
{
case MAPGEN_MAZE:
case MAPGEN_PERLIN:
bcfg << QString("e$maze_size %1").arg(pMapContainer->getMazeSize()).toUtf8();
break;
case MAPGEN_DRAWN:
{
QByteArray data = pMapContainer->getDrawnMapData();
while(data.size() > 0)
{
QByteArray tmp = data;
tmp.truncate(200);
tmp.prepend("edraw ");
bcfg << tmp;
data.remove(0, 200);
}
break;
}
default:
;
}
QByteArray result;
foreach(QByteArray ba, bcfg)
HWProto::addByteArrayToBuffer(result, ba);
return result;
}
QgsRasterLayer* QgsRemoteOWSBuilder::wcsLayerFromUrl( const QString &url,
const QString &layerName,
QList<QTemporaryFile*> &filesToRemove,
QList<QgsMapLayer*> &layersToRemove,
bool allowCaching ) const
{
Q_UNUSED( layerName );
Q_UNUSED( allowCaching );
QgsDebugMsg( "Entering" );
//write server url and coverage name to a temporary file
QString fileName = createTempFile();
if ( fileName.isEmpty() )
{
return 0;
}
QFile tempFile( fileName );
QTemporaryFile* tmpFile = new QTemporaryFile();
if ( !tmpFile->open() )
{
delete tmpFile;
return 0;
}
filesToRemove.push_back( tmpFile ); //make sure the temporary file gets deleted after each request
QgsDebugMsg( "opening successful" );
QgsDebugMsg( "url: " + url );
//extract server url and coverage name from string
QStringList serverSplit = url.split( "?" );
if ( serverSplit.size() < 2 )
{
QgsDebugMsg( "error, no '?' contained in url" );
return 0;
}
QString serverUrl = serverSplit.at( 0 );
QString request = serverSplit.at( 1 );
QStringList parameterSplit = request.split( "&" );
QString coverageName;
QString format;
for ( int i = 0; i < parameterSplit.size(); ++i )
{
if ( parameterSplit.at( i ).startsWith( "COVERAGE", Qt::CaseInsensitive ) )
{
coverageName = parameterSplit.at( i ).split( "=" ).at( 1 );
}
else if ( parameterSplit.at( i ).startsWith( "FORMAT", Qt::CaseInsensitive ) )
{
format = parameterSplit.at( i ).split( "=" ).at( 1 );
}
}
if ( coverageName.isEmpty() )
{
QgsDebugMsg( "coverage name is empty" );
return 0;
}
if ( format.isEmpty() )
{
format = "GeoTIFF"; //use geotiff as default
}
QgsDebugMsg( "wcs server url: " + serverUrl );
QgsDebugMsg( "coverage name: " + coverageName );
//fetch WCS layer in the current resolution as geotiff
QString wcsRequest = serverUrl + "?SERVICE=WCS&VERSION=1.0.0&REQUEST=GetCoverage&COVERAGE=" + coverageName + "&FORMAT=" + format;
//CRS (or SRS)
std::map<QString, QString>::const_iterator crsIt = mParameterMap.find( "CRS" );
if ( crsIt == mParameterMap.end() )
{
crsIt = mParameterMap.find( "SRS" );
if ( crsIt == mParameterMap.end() )
{
QgsDebugMsg( "No CRS or SRS parameter found for wcs layer, returning 0" );
return 0;
}
}
wcsRequest += "&CRS=";
wcsRequest += crsIt->second;
//width
std::map<QString, QString>::const_iterator widthIt = mParameterMap.find( "WIDTH" );
if ( widthIt == mParameterMap.end() )
{
QgsDebugMsg( "No WIDTH parameter found for wcs layer, returning 0" );
return 0;
}
wcsRequest += "&WIDTH=";
wcsRequest += widthIt->second;
//height
std::map<QString, QString>::const_iterator heightIt = mParameterMap.find( "HEIGHT" );
if ( heightIt == mParameterMap.end() )
{
QgsDebugMsg( "No HEIGHT parameter found for wcs layer, returning 0" );
return 0;
}
wcsRequest += "&HEIGHT=";
wcsRequest += heightIt->second;
//bbox
std::map<QString, QString>::const_iterator bboxIt = mParameterMap.find( "BBOX" );
if ( bboxIt == mParameterMap.end() )
{
QgsDebugMsg( "No BBOX parameter found for wcs layer, returning 0" );
return 0;
}
wcsRequest += "&BBOX=";
wcsRequest += bboxIt->second;
QgsDebugMsg( "WCS request is: " + wcsRequest );
//make request and store byte array into temporary file
QgsHttpTransaction httpTransaction( wcsRequest );
QByteArray result;
if ( !httpTransaction.getSynchronously( result ) )
{
return 0;
}
QDataStream tempFileStream( &tempFile );
tempFileStream.writeRawData( result.data(), result.size() );
tempFile.close();
QgsRasterLayer* rl = new QgsRasterLayer( fileName, layerNameFromUri( fileName ) );
layersToRemove.push_back( rl ); //make sure the layer gets deleted after each request
return rl;
}
bool BaseTransport::encodeMessage( const SyncMLMessage& aMessage, QByteArray& aData )
{
FUNCTION_CALL_TRACE;
bool success = false;
if( useWbXml() )
{
LibWbXML2Encoder encoder;
if( encoder.encodeToWbXML( aMessage,
aMessage.getProtocolVersion(),
aData ) )
{
LOG_DEBUG( "WbXML encoding successful" );
#ifndef QT_NO_DEBUG
QByteArray xml;
if( encoder.encodeToXML( aMessage,
aMessage.getProtocolVersion(),
xml, true ) )
{
LOG_PROTOCOL( "\nSending message:\n=========\n" << xml << "\n=========size:"<<xml.size());
}
else
{
LOG_PROTOCOL( "Failed to print request" );
}
#endif // QT_NO_DEBUG
success = true;
}
else
{
LOG_CRITICAL( "WbXML encoding failed!" );
}
}
else
{
QtEncoder encoder;
if( encoder.encodeToXML( aMessage, aData, false ) )
{
LOG_DEBUG( "XML encoding successful" );
#ifndef QT_NO_DEBUG
QByteArray xml;
if( encoder.encodeToXML( aMessage, xml, true ) ) {
LOG_PROTOCOL( "\nSending message:\n=========\n" << xml << "\n=========");
} else {
LOG_PROTOCOL( "Failed to print request" );
}
#endif // QT_NO_DEBUG
success = true;
}
else
{
LOG_CRITICAL( "XML encoding failed!" );
}
}
return success;
}
void libASS::addASSEvent( const QByteArray &event )
{
if ( !ass_sub_track || !ass_sub_renderer || event.isEmpty() )
return;
ass_process_data( ass_sub_track, ( char * )event.data(), event.size() );
}
void libASS::addFont( const QByteArray &name, const QByteArray &data )
{
ass_add_font( ass, ( char * )name.data(), ( char * )data.data(), data.size() );
}