bool QXmppSaslClientFacebook::respond(const QByteArray &challenge, QByteArray &response)
{
if (m_step == 0) {
// no initial response
response = QByteArray();
m_step++;
return true;
} else if (m_step == 1) {
// parse request
#if QT_VERSION >= 0x050000
QUrlQuery requestUrl(challenge);
#else
QUrl requestUrl;
requestUrl.setEncodedQuery(challenge);
#endif
if (!requestUrl.hasQueryItem("method") || !requestUrl.hasQueryItem("nonce")) {
warning("QXmppSaslClientFacebook : Invalid challenge, nonce or method missing");
return false;
}
// build response
#if QT_VERSION >= 0x050000
QUrlQuery responseUrl;
#else
QUrl responseUrl;
#endif
responseUrl.addQueryItem("access_token", password());
responseUrl.addQueryItem("api_key", username());
responseUrl.addQueryItem("call_id", 0);
responseUrl.addQueryItem("method", requestUrl.queryItemValue("method"));
responseUrl.addQueryItem("nonce", requestUrl.queryItemValue("nonce"));
responseUrl.addQueryItem("v", "1.0");
#if QT_VERSION >= 0x050000
response = responseUrl.query().toUtf8();
#else
response = responseUrl.encodedQuery();
#endif
m_step++;
return true;
} else {
warning("QXmppSaslClientFacebook : Invalid step");
return false;
}
}
int QgsWFSData::getWFSData()
{
XML_Parser p = XML_ParserCreateNS( NULL, NS_SEPARATOR );
XML_SetUserData( p, this );
XML_SetElementHandler( p, QgsWFSData::start, QgsWFSData::end );
XML_SetCharacterDataHandler( p, QgsWFSData::chars );
//separate host from query string
QUrl requestUrl( mUri );
int portNr = requestUrl.port();
if ( portNr != -1 )
{
mHttp.setHost( requestUrl.host(), portNr );
}
else
{
mHttp.setHost( requestUrl.host() );
}
//mHttp.get( mUri );
mHttp.get( requestUrl.path() + "?" + QString( requestUrl.encodedQuery() ) );
//loop to read the data
QByteArray readData;
int atEnd = 0;
qWarning( "Entering loop" );
while ( !mFinished || mHttp.bytesAvailable() > 0 )
{
if ( mFinished )
{
atEnd = 1;
}
if ( mHttp.bytesAvailable() != 0 )
{
readData = mHttp.readAll();
XML_Parse( p, readData.data(), readData.size(), atEnd );
}
qApp->processEvents( QEventLoop::ExcludeUserInputEvents );
}
qWarning( "Left loop" );
return 0; //soon
}
/* FIXME: Some requests never receive response
Need more tests. When searching automatically AND manually on the same track (same libId),
sometimes one of the responses does not call the slot. Therefore, it should because the requests
and associated QNetworkReply are totally different objects and should not be in conflict.
Maybe related to QNetworkSignalMapper. Also, what is the benefit of having a mapper here ? A simple
QMap<QReply, QString> should be sufficient
*/
void SearchProvider::naturalSearch(QMap<QString, QString> *id_SearchText_Map)
{
O1Beatport * oauthManager = O1Beatport::instance();
O1Requestor requestManager(_manager, oauthManager);
if(!oauthManager->linked()) {
LOG_ERROR("Unable to perform a search from text, Beatport OAuth is not linked");
// TODO: emit an error signal
return;
}
QUrl requestUrl(TYM_BEATPORT_API_URL + _searchPath);
QMapIterator<QString, QString> searchList(*id_SearchText_Map);
while(searchList.hasNext()) {
searchList.next();
QString libId = searchList.key();
QString text = searchList.value();
if(text.isEmpty()) return;
// Replace underscores by spaces (and prevent multiple spaces)
Utils::instance()->simplifySpaces(text.replace('_', ' '));
QList<O1RequestParameter> params;
params << O1RequestParameter("query", text.toLatin1());
params << O1RequestParameter("facets", "fieldType:track");
requestUrl.setQuery(QUrlQuery(O1::createQueryParams(params)));
QNetworkRequest request(requestUrl);
QNetworkReply *reply = requestManager.get(request, params);
_naturalSearchMapper->setMapping(reply, libId);
connect(reply, SIGNAL(finished()),
_naturalSearchMapper, SLOT(map()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(requestError(QNetworkReply::NetworkError)));
LOG_DEBUG(QString("Request sent for search \"%1\"").arg(text));
}
delete id_SearchText_Map;
}
QString WizCommonApiEntry::asServerUrl()
{
//使用endpoints获取as使用的API地址和之前的不同
QString strAsUrl = getUrlFromCache("wizas");
if (strAsUrl.isEmpty())
{
strAsUrl = requestUrl("as");
updateUrlCache("wizas", strAsUrl);
}
if (!strAsUrl.startsWith("http"))
{
qCritical() << "request url by command error. command : sync_https, return : " << strAsUrl;
strAsUrl.clear();
}
return strAsUrl;
}
void ClipperNetwork::convertToQRCode(QString text)
{
QUrlQuery requestQuery;
requestQuery.addQueryItem("d", QUrl::toPercentEncoding(text));
QUrl requestUrl(QR_CODE_URL);
requestUrl.setQuery(requestQuery);
QNetworkReply *networkRequest = network->get(QNetworkRequest(requestUrl));
connect(networkRequest, &QNetworkReply::finished, [networkRequest, this]() {
if (networkRequest->error() == QNetworkReply::NoError)
{
std::shared_ptr<QPixmap> qrCode(new QPixmap());
qrCode->loadFromData(networkRequest->readAll());
emit qrCodeReady(qrCode);
}
else
emit failure(networkRequest->errorString());
networkRequest->deleteLater();
});
}
QPlaceDetailsReply *QPlaceManagerEngineNokiaV2::getPlaceDetails(const QString &placeId)
{
QUrl requestUrl(QString::fromLatin1("http://") + m_uriProvider->getCurrentHost() +
QLatin1String("/places/v1/places/") + placeId);
QUrlQuery queryItems;
queryItems.addQueryItem(QLatin1String("tf"), QLatin1String("html"));
//queryItems.append(qMakePair<QString, QString>(QLatin1String("size"), QString::number(5)));
//queryItems.append(qMakePair<QString, QString>(QLatin1String("image_dimensions"), QLatin1String("w64-h64,w100")));
requestUrl.setQuery(queryItems);
QNetworkReply *networkReply = sendRequest(requestUrl);
QPlaceDetailsReplyImpl *reply = new QPlaceDetailsReplyImpl(networkReply, this);
reply->setPlaceId(placeId);
connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
connect(reply, SIGNAL(error(QPlaceReply::Error,QString)),
this, SLOT(replyError(QPlaceReply::Error,QString)));
return reply;
}
QPlaceSearchReply *QPlaceManagerEngineOsm::search(const QPlaceSearchRequest &request)
{
bool unsupported = false;
// Only public visibility supported
unsupported |= request.visibilityScope() != QLocation::UnspecifiedVisibility &&
request.visibilityScope() != QLocation::PublicVisibility;
unsupported |= request.searchTerm().isEmpty() && request.categories().isEmpty();
if (unsupported)
return QPlaceManagerEngine::search(request);
QUrlQuery queryItems;
queryItems.addQueryItem(QStringLiteral("format"), QStringLiteral("jsonv2"));
//queryItems.addQueryItem(QStringLiteral("accept-language"), QStringLiteral("en"));
QGeoRectangle boundingBox;
QGeoShape searchArea = request.searchArea();
switch (searchArea.type()) {
case QGeoShape::CircleType: {
QGeoCircle c(searchArea);
qreal radius = c.radius();
if (radius < 0)
radius = 50000;
boundingBox = QGeoRectangle(c.center().atDistanceAndAzimuth(radius, -45),
c.center().atDistanceAndAzimuth(radius, 135));
break;
}
case QGeoShape::RectangleType:
boundingBox = searchArea;
break;
default:
;
}
if (!boundingBox.isEmpty()) {
queryItems.addQueryItem(QStringLiteral("bounded"), QStringLiteral("1"));
QString coordinates;
coordinates = QString::number(boundingBox.topLeft().longitude()) + QLatin1Char(',') +
QString::number(boundingBox.topLeft().latitude()) + QLatin1Char(',') +
QString::number(boundingBox.bottomRight().longitude()) + QLatin1Char(',') +
QString::number(boundingBox.bottomRight().latitude());
queryItems.addQueryItem(QStringLiteral("viewbox"), coordinates);
}
QStringList queryParts;
if (!request.searchTerm().isEmpty())
queryParts.append(request.searchTerm());
foreach (const QPlaceCategory &category, request.categories()) {
QString id = category.categoryId();
int index = id.indexOf(QLatin1Char('='));
if (index != -1)
id = id.mid(index+1);
queryParts.append(QLatin1Char('[') + id + QLatin1Char(']'));
}
queryItems.addQueryItem(QStringLiteral("q"), queryParts.join(QLatin1Char('+')));
QVariantMap parameters = request.searchContext().toMap();
QStringList placeIds = parameters.value(QStringLiteral("ExcludePlaceIds")).toStringList();
if (!placeIds.isEmpty())
queryItems.addQueryItem(QStringLiteral("exclude_place_ids"), placeIds.join(QLatin1Char(',')));
queryItems.addQueryItem(QStringLiteral("addressdetails"), QStringLiteral("1"));
QUrl requestUrl(m_urlPrefix);
requestUrl.setQuery(queryItems);
QNetworkReply *networkReply = m_networkManager->get(QNetworkRequest(requestUrl));
QPlaceSearchReplyOsm *reply = new QPlaceSearchReplyOsm(request, networkReply, this);
connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
connect(reply, SIGNAL(error(QPlaceReply::Error,QString)),
this, SLOT(replyError(QPlaceReply::Error,QString)));
return reply;
}
QString WizApiEntry::crashReportUrl()
{
QString strUrl = requestUrl("crash_http");
return strUrl;
}
QString WizApiEntry::analyzerUploadUrl()
{
QString analyzerUrl = requestUrl("analyzer");
return analyzerUrl;
}
void DocumentBrowser::reloadUrl()
{
emit requestUrl(m_url);
}
void QgsAmsProvider::draw( const QgsRectangle &viewExtent, int pixelWidth, int pixelHeight )
{
if ( !mCachedImage.isNull() && mCachedImageExtent == viewExtent )
{
return;
}
QgsDataSourceUri dataSource( dataSourceUri() );
const QString authcfg = dataSource.param( QStringLiteral( "authcfg" ) );
// Use of tiles currently only implemented if service CRS is meter based
if ( mServiceInfo[QStringLiteral( "singleFusedMapCache" )].toBool() && mCrs.mapUnits() == QgsUnitTypes::DistanceMeters )
{
// Compute ideal resolution
// - Measure distance in meters along lower and upper edge of bounding box
// - Target resolution is the coarser resolution (resolution = distMeters / pixelWidth)
double width = viewExtent.xMaximum() - viewExtent.xMinimum();
double targetRes = width / ( pixelWidth );
// Tiles available, assemble image from tiles
QVariantMap tileInfo = mServiceInfo[QStringLiteral( "tileInfo" )].toMap();
int tileWidth = tileInfo[QStringLiteral( "cols" )].toInt();
int tileHeight = tileInfo[QStringLiteral( "rows" )].toInt();
QVariantMap origin = tileInfo[QStringLiteral( "origin" )].toMap();
double ox = origin[QStringLiteral( "x" )].toDouble();
double oy = origin[QStringLiteral( "y" )].toDouble();
// Search matching resolution (tile resolution <= targetRes)
const QList<QVariant> lodEntries = tileInfo[QStringLiteral( "lods" )].toList();
if ( lodEntries.isEmpty() )
{
mCachedImage = QImage();
mCachedImage.fill( Qt::transparent );
return;
}
int level = 0;
double resolution = lodEntries.front().toMap()[QStringLiteral( "resolution" )].toDouble();
for ( const QVariant &lodEntry : lodEntries )
{
QVariantMap lodEntryMap = lodEntry.toMap();
level = lodEntryMap[QStringLiteral( "level" )].toInt();
resolution = lodEntryMap[QStringLiteral( "resolution" )].toDouble();
if ( lodEntryMap[QStringLiteral( "resolution" )].toDouble() <= 1.5 * targetRes )
{
break;
}
}
// Get necessary tiles to fill extent
// tile_x = ox + i * (resolution * tileWidth)
// tile_y = oy - j * (resolution * tileHeight)
int ixStart = std::floor( ( viewExtent.xMinimum() - ox ) / ( tileWidth * resolution ) );
int iyStart = std::floor( ( oy - viewExtent.yMaximum() ) / ( tileHeight * resolution ) );
int ixEnd = std::ceil( ( viewExtent.xMaximum() - ox ) / ( tileWidth * resolution ) );
int iyEnd = std::ceil( ( oy - viewExtent.yMinimum() ) / ( tileHeight * resolution ) );
double imX = ( viewExtent.xMinimum() - ox ) / resolution;
double imY = ( oy - viewExtent.yMaximum() ) / resolution;
// Query tiles
int ixCount = ( ixEnd - ixStart + 1 );
QVector<QByteArray> results( ixCount * ( iyEnd - iyStart + 1 ) );
QVector<QUrl> queries( ixCount * ( iyEnd - iyStart + 1 ) );
for ( int iy = iyStart; iy <= iyEnd; ++iy )
{
for ( int ix = ixStart; ix <= ixEnd; ++ix )
{
queries[( iy - iyStart ) * ixCount + ( ix - ixStart )] = QUrl( dataSource.param( QStringLiteral( "url" ) ) + QStringLiteral( "/tile/%1/%2/%3" ).arg( level ).arg( iy ).arg( ix ) );
}
}
QgsArcGisAsyncParallelQuery query;
QEventLoop evLoop;
connect( &query, &QgsArcGisAsyncParallelQuery::finished, &evLoop, &QEventLoop::quit );
query.start( queries, &results, true );
evLoop.exec( QEventLoop::ExcludeUserInputEvents );
// Fill image
mCachedImage = QImage( pixelWidth, pixelHeight, QImage::Format_ARGB32 );
mCachedImage.fill( Qt::transparent );
QPainter painter( &mCachedImage );
painter.setRenderHint( QPainter::SmoothPixmapTransform, true );
double resScale = resolution / targetRes;
painter.scale( resScale, resScale );
for ( int iy = iyStart; iy <= iyEnd; ++iy )
{
for ( int ix = ixStart; ix <= ixEnd; ++ix )
{
QImage image = QImage::fromData( results[( iy - iyStart ) * ixCount + ( ix - ixStart )], tileInfo[QStringLiteral( "format" )].toByteArray() );
painter.drawImage( QPointF( ix * tileWidth - imX, iy * tileHeight - imY ), image );
}
}
}
else
{
QUrl requestUrl( dataSource.param( QStringLiteral( "url" ) ) + "/export" );
requestUrl.addQueryItem( QStringLiteral( "bbox" ), QStringLiteral( "%1,%2,%3,%4" ).arg( viewExtent.xMinimum(), 0, 'f', -1 ).arg( viewExtent.yMinimum(), 0, 'f', -1 ).arg( viewExtent.xMaximum(), 0, 'f', -1 ).arg( viewExtent.yMaximum(), 0, 'f', -1 ) );
requestUrl.addQueryItem( QStringLiteral( "size" ), QStringLiteral( "%1,%2" ).arg( pixelWidth ).arg( pixelHeight ) );
requestUrl.addQueryItem( QStringLiteral( "format" ), dataSource.param( QStringLiteral( "format" ) ) );
requestUrl.addQueryItem( QStringLiteral( "layers" ), QStringLiteral( "show:%1" ).arg( dataSource.param( QStringLiteral( "layer" ) ) ) );
requestUrl.addQueryItem( QStringLiteral( "transparent" ), QStringLiteral( "true" ) );
requestUrl.addQueryItem( QStringLiteral( "f" ), QStringLiteral( "image" ) );
QByteArray reply = QgsArcGisRestUtils::queryService( requestUrl, authcfg, mErrorTitle, mError );
mCachedImage = QImage::fromData( reply, dataSource.param( QStringLiteral( "format" ) ).toLatin1() );
if ( mCachedImage.format() != QImage::Format_ARGB32 )
{
mCachedImage = mCachedImage.convertToFormat( QImage::Format_ARGB32 );
}
}
}
QPlaceContentReply *QPlaceManagerEngineNokiaV2::getPlaceContent(const QString &placeId,
const QPlaceContentRequest &request)
{
QUrl requestUrl(QString::fromLatin1("http://") + m_uriProvider->getCurrentHost() +
QLatin1String("/places/v1/places/") + placeId + QLatin1String("/media/"));
QNetworkReply *networkReply = 0;
QUrlQuery queryItems;
switch (request.contentType()) {
case QPlaceContent::ImageType:
requestUrl.setPath(requestUrl.path() + QLatin1String("images"));
queryItems.addQueryItem(QLatin1String("tf"), QLatin1String("html"));
if (request.limit() > 0) {
queryItems.addQueryItem(QLatin1String("size"),
QString::number(request.limit()));
}
if (request.offset() > -1) {
queryItems.addQueryItem(QLatin1String("offset"),
QString::number(request.offset()));
}
//queryItems.append(qMakePair<QString, QString>(QLatin1String("image_dimensions"), QLatin1String("w64-h64,w100")));
requestUrl.setQuery(queryItems);
networkReply = sendRequest(requestUrl);
break;
case QPlaceContent::ReviewType:
requestUrl.setPath(requestUrl.path() + QLatin1String("reviews"));
queryItems.addQueryItem(QLatin1String("tf"), QLatin1String("html"));
if (request.limit() > 0) {
queryItems.addQueryItem(QLatin1String("size"),
QString::number(request.limit()));
}
if (request.offset() > -1) {
queryItems.addQueryItem(QLatin1String("offset"),
QString::number(request.offset()));
}
requestUrl.setQuery(queryItems);
networkReply = sendRequest(requestUrl);
break;
case QPlaceContent::EditorialType:
requestUrl.setPath(requestUrl.path() + QLatin1String("editorials"));
queryItems.addQueryItem(QLatin1String("tf"), QLatin1String("html"));
if (request.limit() > 0) {
queryItems.addQueryItem(QLatin1String("size"),
QString::number(request.limit()));
}
if (request.offset() > -1) {
queryItems.addQueryItem(QLatin1String("offset"),
QString::number(request.offset()));
}
requestUrl.setQuery(queryItems);
networkReply = sendRequest(requestUrl);
break;
case QPlaceContent::NoType:
;
}
QPlaceContentReply *reply = new QPlaceContentReplyImpl(request, networkReply, this);
connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
connect(reply, SIGNAL(error(QPlaceReply::Error,QString)),
this, SLOT(replyError(QPlaceReply::Error,QString)));
if (!networkReply) {
QMetaObject::invokeMethod(reply, "setError", Qt::QueuedConnection,
Q_ARG(QPlaceReply::Error, QPlaceReply::UnsupportedError),
Q_ARG(QString, QString("Retrieval of given content type not supported.")));
}
return reply;
}
UpdateFeeds::UpdateFeeds(QObject *parent, bool addFeed)
: QObject(parent)
, updateObject_(NULL)
, requestFeed_(NULL)
, parseObject_(NULL)
, faviconObject_(NULL)
, updateFeedThread_(NULL)
, getFaviconThread_(NULL)
, addFeed_(addFeed)
, saveMemoryDBTimer_(NULL)
{
getFeedThread_ = new QThread();
getFeedThread_->setObjectName("getFeedThread_");
updateFeedThread_ = new QThread();
updateFeedThread_->setObjectName("updateFeedThread_");
Settings settings;
int timeoutRequest = settings.value("Settings/timeoutRequest", 15).toInt();
int numberRequests = settings.value("Settings/numberRequest", 10).toInt();
int numberRepeats = settings.value("Settings/numberRepeats", 2).toInt();
requestFeed_ = new RequestFeed(timeoutRequest, numberRequests, numberRepeats);
parseObject_ = new ParseObject();
if (addFeed_) {
connect(parent, SIGNAL(signalRequestUrl(int,QString,QDateTime,QString)),
requestFeed_, SLOT(requestUrl(int,QString,QDateTime,QString)));
connect(requestFeed_, SIGNAL(getUrlDone(int,int,QString,QString,QByteArray,QDateTime,QString)),
parent, SLOT(getUrlDone(int,int,QString,QString,QByteArray,QDateTime,QString)));
connect(parent, SIGNAL(xmlReadyParse(QByteArray,int,QDateTime,QString)),
parseObject_, SLOT(parseXml(QByteArray,int,QDateTime,QString)));
connect(parseObject_, SIGNAL(signalFinishUpdate(int,bool,int,QString)),
parent, SLOT(slotUpdateFeed(int,bool,int,QString)));
} else {
getFaviconThread_ = new QThread();
getFaviconThread_->setObjectName("getFaviconThread_");
updateObject_ = new UpdateObject();
faviconObject_ = new FaviconObject();
connect(updateObject_, SIGNAL(signalRequestUrl(int,QString,QDateTime,QString)),
requestFeed_, SLOT(requestUrl(int,QString,QDateTime,QString)));
connect(requestFeed_, SIGNAL(getUrlDone(int,int,QString,QString,QByteArray,QDateTime,QString)),
updateObject_, SLOT(getUrlDone(int,int,QString,QString,QByteArray,QDateTime,QString)));
connect(requestFeed_, SIGNAL(setStatusFeed(int,QString)),
parent, SLOT(setStatusFeed(int,QString)));
connect(parent, SIGNAL(signalStopUpdate()),
requestFeed_, SLOT(stopRequest()));
connect(parent, SIGNAL(signalGetFeedTimer(int)),
updateObject_, SLOT(slotGetFeedTimer(int)));
connect(parent, SIGNAL(signalGetAllFeedsTimer()),
updateObject_, SLOT(slotGetAllFeedsTimer()));
connect(parent, SIGNAL(signalGetAllFeeds()),
updateObject_, SLOT(slotGetAllFeeds()));
connect(parent, SIGNAL(signalGetFeed(int,QString,QDateTime,int)),
updateObject_, SLOT(slotGetFeed(int,QString,QDateTime,int)));
connect(parent, SIGNAL(signalGetFeedsFolder(QString)),
updateObject_, SLOT(slotGetFeedsFolder(QString)));
connect(parent, SIGNAL(signalImportFeeds(QByteArray)),
updateObject_, SLOT(slotImportFeeds(QByteArray)));
connect(updateObject_, SIGNAL(showProgressBar(int)),
parent, SLOT(showProgressBar(int)));
connect(updateObject_, SIGNAL(loadProgress(int)),
parent, SLOT(slotSetValue(int)));
connect(updateObject_, SIGNAL(signalMessageStatusBar(QString,int)),
parent, SLOT(showMessageStatusBar(QString,int)));
connect(updateObject_, SIGNAL(signalUpdateFeedsModel()),
parent, SLOT(feedsModelReload()),
Qt::BlockingQueuedConnection);
connect(updateObject_, SIGNAL(xmlReadyParse(QByteArray,int,QDateTime,QString)),
parseObject_, SLOT(parseXml(QByteArray,int,QDateTime,QString)),
Qt::QueuedConnection);
connect(parseObject_, SIGNAL(signalFinishUpdate(int,bool,int,QString)),
updateObject_, SLOT(finishUpdate(int,bool,int,QString)),
Qt::QueuedConnection);
connect(updateObject_, SIGNAL(feedUpdated(int,bool,int,bool)),
parent, SLOT(slotUpdateFeed(int,bool,int,bool)));
connect(updateObject_, SIGNAL(setStatusFeed(int,QString)),
parent, SLOT(setStatusFeed(int,QString)));
qRegisterMetaType<FeedCountStruct>("FeedCountStruct");
connect(parseObject_, SIGNAL(feedCountsUpdate(FeedCountStruct)),
parent, SLOT(slotFeedCountsUpdate(FeedCountStruct)));
connect(parseObject_, SIGNAL(signalPlaySound(QString)),
parent, SLOT(slotPlaySound(QString)));
connect(parseObject_, SIGNAL(signalAddColorList(int,QString)),
parent, SLOT(slotAddColorList(int,QString)));
connect(parent, SIGNAL(signalNextUpdate(bool)),
updateObject_, SLOT(slotNextUpdateFeed(bool)));
connect(updateObject_, SIGNAL(signalUpdateModel(bool)),
parent, SLOT(feedsModelReload(bool)));
connect(updateObject_, SIGNAL(signalUpdateNews()),
parent, SLOT(slotUpdateNews()));
connect(updateObject_, SIGNAL(signalCountsStatusBar(int,int)),
parent, SLOT(slotCountsStatusBar(int,int)));
connect(parent, SIGNAL(signalRecountCategoryCounts()),
updateObject_, SLOT(slotRecountCategoryCounts()));
qRegisterMetaType<QList<int> >("QList<int>");
connect(updateObject_, SIGNAL(signalRecountCategoryCounts(QList<int>,QList<int>,QList<int>,QStringList)),
parent, SLOT(slotRecountCategoryCounts(QList<int>,QList<int>,QList<int>,QStringList)));
connect(parent, SIGNAL(signalRecountFeedCounts(int,bool)),
updateObject_, SLOT(slotRecountFeedCounts(int,bool)));
connect(updateObject_, SIGNAL(feedCountsUpdate(FeedCountStruct)),
parent, SLOT(slotFeedCountsUpdate(FeedCountStruct)));
connect(updateObject_, SIGNAL(signalFeedsViewportUpdate()),
parent, SLOT(slotFeedsViewportUpdate()));
connect(parent, SIGNAL(signalSetFeedRead(int,int,int,QList<int>)),
updateObject_, SLOT(slotSetFeedRead(int,int,int,QList<int>)));
connect(parent, SIGNAL(signalMarkFeedRead(int,bool,bool)),
updateObject_, SLOT(slotMarkFeedRead(int,bool,bool)));
connect(parent, SIGNAL(signalRefreshInfoTray()),
updateObject_, SLOT(slotRefreshInfoTray()));
connect(updateObject_, SIGNAL(signalRefreshInfoTray(int,int)),
parent, SLOT(slotRefreshInfoTray(int,int)));
connect(parent, SIGNAL(signalUpdateStatus(int,bool)),
updateObject_, SLOT(slotUpdateStatus(int,bool)));
connect(parent, SIGNAL(signalMarkAllFeedsRead()),
updateObject_, SLOT(slotMarkAllFeedsRead()));
connect(parent, SIGNAL(signalMarkReadCategory(int,int)),
updateObject_, SLOT(slotMarkReadCategory(int,int)));
connect(parent, SIGNAL(signalRefreshNewsView(int)),
updateObject_, SIGNAL(signalMarkAllFeedsRead(int)));
connect(updateObject_, SIGNAL(signalMarkAllFeedsRead(int)),
parent, SLOT(slotRefreshNewsView(int)));
connect(parent, SIGNAL(signalMarkAllFeedsOld()),
updateObject_, SLOT(slotMarkAllFeedsOld()));
connect(parent, SIGNAL(signalSetFeedsFilter(bool)),
updateObject_, SIGNAL(signalSetFeedsFilter(bool)));
connect(updateObject_, SIGNAL(signalSetFeedsFilter(bool)),
parent, SLOT(setFeedsFilter(bool)));
connect(mainApp, SIGNAL(signalSqlQueryExec(QString)),
updateObject_, SLOT(slotSqlQueryExec(QString)));
connect(mainApp, SIGNAL(signalRunUserFilter(int, int)),
parseObject_, SLOT(runUserFilter(int, int)));
// faviconObject_
connect(parent, SIGNAL(faviconRequestUrl(QString,QString)),
faviconObject_, SLOT(requestUrl(QString,QString)));
connect(faviconObject_, SIGNAL(signalIconRecived(QString,QByteArray,QString)),
parent, SLOT(slotIconFeedPreparing(QString,QByteArray,QString)));
connect(parent, SIGNAL(signalIconFeedReady(QString,QByteArray)),
updateObject_, SLOT(slotIconSave(QString,QByteArray)));
connect(updateObject_, SIGNAL(signalIconUpdate(int,QByteArray)),
parent, SLOT(slotIconFeedUpdate(int,QByteArray)));
updateObject_->moveToThread(updateFeedThread_);
faviconObject_->moveToThread(getFaviconThread_);
getFaviconThread_->start(QThread::LowPriority);
startSaveTimer();
}
requestFeed_->moveToThread(getFeedThread_);
parseObject_->moveToThread(updateFeedThread_);
getFeedThread_->start(QThread::LowPriority);
updateFeedThread_->start(QThread::LowPriority);
}