void ImageLoader::onReplyFinished()
{
QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
QString response;
if (reply) {
if (reply->error() == QNetworkReply::NoError) {
const int available = reply->bytesAvailable();
if (available > 0) {
const QByteArray data(reply->readAll());
// Setup the image processing thread
ImageProcessor *imageProcessor = new ImageProcessor(data);
m_thread = new QThread(this);
// Move the image processor to the worker thread
imageProcessor->moveToThread(m_thread);
// Invoke ImageProcessor's start() slot as soon as the worker thread has started
connect(m_thread, SIGNAL(started()), imageProcessor, SLOT(start()));
// Delete the worker thread automatically after it has finished
connect(m_thread, SIGNAL(finished()), m_thread, SLOT(deleteLater()));
/*
* Invoke our onProcessingFinished slot after the processing has finished.
* Since imageProcessor and 'this' are located in different threads we use 'QueuedConnection' to
* allow a cross-thread boundary invocation. In this case the QImage parameter is copied in a thread-safe way
* from the worker thread to the main thread.
*/
connect(imageProcessor, SIGNAL(finished(QImage)), this, SLOT(onImageProcessingFinished(QImage)), Qt::QueuedConnection);
// Terminate the thread after the processing has finished
connect(imageProcessor, SIGNAL(finished(QImage)), m_thread, SLOT(quit()));
m_thread->start();
}
} else {
m_label = tr("Error: %1 status: %2").arg(reply->errorString(), reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toString());
emit labelChanged();
m_loading = false;
emit loadingChanged();
}
reply->deleteLater();
} else {
m_label = tr("Download failed. Check internet connection");
emit labelChanged();
m_loading = false;
emit loadingChanged();
}
}
void DeclarativeWebContainer::setWebPage(DeclarativeWebPage *webPage)
{
if (m_webPage != webPage) {
// Disconnect previous page.
if (m_webPage) {
m_webPage->disconnect(this);
}
m_webPage = webPage;
if (m_webPage) {
m_tabId = m_webPage->tabId();
} else {
m_tabId = 0;
}
emit contentItemChanged();
emit tabIdChanged();
emit loadingChanged();
updateUrl(url());
updateTitle(title());
setLoadProgress(m_webPage ? m_webPage->loadProgress() : 0);
}
}
void WebImageView::downloadProgressed(qint64 bytes,qint64 total) {
QNetworkReply * reply = qobject_cast<QNetworkReply*>(sender());
if(reply==replies.back()){
mLoading = double(bytes)/double(total);
emit loadingChanged();
}
}
void ReadabilityArticle::tryLoad()
{
if (!m_api) {
m_error = "Cannot access article content (Invalid API Configuration)";
}
else if (!m_url.isValid()) {
m_error = "Cannot access article content (Invalid URL)";
}
else {
m_error.clear();
if (m_request) {
disconnect(m_request);
m_request->disconnect(this);
m_request->cancel();
m_request->deleteLater();
}
m_request = m_api->getParseRequest(m_url);
connect(m_request, SIGNAL(responseReady(QJsonObject)),
this, SLOT(onResponseReceived(QJsonObject)));
connect(m_request, SIGNAL(requestError(QNetworkReply::NetworkError,QString)),
this, SLOT(onRequestError(QNetworkReply::NetworkError,QString)));
m_request->send();
emit startedLoading();
}
emit loadingChanged();
emit errorChanged(m_error);
}
void MusicCollector::removeCollection(const QString &id)
{
if (id.toInt() == 0) return;
if (playlistId == 0) {
nextOperation = OperationRemoveCollection;
operatingId = id;
if (!currentReply || currentReply->property(KeyOperation).toInt() != OperationLoadPid) {
refresh();
}
return;
}
if (currentReply && currentReply->isRunning())
currentReply->abort();
QNetworkRequest req;
req.setUrl(QString(ApiBaseUrl).append("/playlist/manipulate/tracks"));
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QByteArray postData;
postData.append("trackIds=").append(QString("[%1]").arg(id).toAscii().toPercentEncoding());
postData.append("&pid=").append(QByteArray::number(playlistId));
postData.append("&op=del");
checkNAM();
currentReply = manager->post(req, postData);
currentReply->setProperty(KeyOperation, OperationRemoveCollection);
connect(currentReply, SIGNAL(finished()), SLOT(requestFinished()), Qt::QueuedConnection);
emit loadingChanged();
}
void ReadabilityArticle::fromJsonObject(QJsonObject description)
{
m_htmlContent = description["content"].toString();
m_domain = QUrl(description["domain"].toString());
m_author = description["author"].toString();
m_url = QUrl(description["url"].toString());
m_shortUrl = QUrl(description["short_url"].toString());
m_title = description["title"].toString();
m_htmlExcerpt = description["excerpt"].toString();
QString direction = description["direction"].toString();
m_direction = (direction == "rtl" ? Qt::RightToLeft : Qt::LeftToRight);
m_wordCount = description["word_count"].toInt();
m_totalPages = description["total_pages"].toInt();
m_publishedDate = QDateTime::fromString(
description["date_published"].toString(),
"yyyy-MM-dd hh:mm:ss");
m_htmlDek = description["dek"].toString();
m_leadImageSource = QUrl(description["lead_image_url"].toString());
//TODO: Need to figure out what 'next_page_id' looks like...not documented very well
// by Readability...
m_nextPageId = description["next_page_id"].toInt();
m_parsedPages = description["rendered_pages"].toInt();
emit loadingChanged();
emit finishedLoading();
}
void ImageLoader::onReplyFinished() {
QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
QString response;
if (reply) {
if (reply->error() == QNetworkReply::NoError) {
const int available = reply->bytesAvailable();
if (available > 0) {
const QByteArray data(reply->readAll());
QImage image;
image.loadFromData(data);
image = image.scaled(120, 120, Qt::KeepAspectRatioByExpanding);
const QImage swappedImage = image.rgbSwapped();
const bb::ImageData imageData = bb::ImageData::fromPixels(swappedImage.bits(), bb::PixelFormat::RGBA_Premultiplied, swappedImage.width(), swappedImage.height(), swappedImage.bytesPerLine());
_image = bb::cascades::Image(imageData);
emit imageChanged();
_loading = false;
emit loadingChanged();
reply->deleteLater();
return;
}
}
reply->deleteLater();
}
// TODO: handle error: set default icon
}
void MusicCollector::loadList()
{
if (playlistId == 0) {
if (nextOperation == OperationNone) {
nextOperation = OperationLoadPlaylist;
operatingId.clear();
}
if (!currentReply || currentReply->property(KeyOperation).toInt() != OperationLoadPid) {
refresh();
}
return;
}
if (currentReply && currentReply->isRunning())
currentReply->abort();
QUrl url(QString(ApiBaseUrl).append("/v2/playlist/detail"));
url.addEncodedQueryItem("id", QByteArray::number(playlistId));
url.addEncodedQueryItem("t", "-1");
url.addEncodedQueryItem("n", "1000");
url.addEncodedQueryItem("s", "0");
checkNAM();
currentReply = manager->get(QNetworkRequest(url));
currentReply->setProperty(KeyOperation, OperationLoadPlaylist);
connect(currentReply, SIGNAL(finished()), SLOT(requestFinished()), Qt::QueuedConnection);
emit loadingChanged();
}
void FBORenderItem::setLoading(bool arg)
{
if (loading == arg)
return;
loading = arg;
emit loadingChanged(arg);
}
void MessageModel::setLoading(bool loading)
{
if (loading != mLoading) {
qDebug() << "<MessageModel::setLoading> Changing value to " << (loading ? "true" : "false");
mLoading = loading;
emit loadingChanged();
}
}
void QWebView::onLoadingChanged(const QWebViewLoadRequestPrivate &loadRequest)
{
if (loadRequest.m_status == QWebView::LoadFailedStatus)
m_progress = 0;
onUrlChanged(loadRequest.m_url);
Q_EMIT loadingChanged(loadRequest);
}
void ImageLoader::onImageProcessingFinished()
{
const QImage swappedImage = m_watcher.future().result().rgbSwapped();
const bb::ImageData imageData = bb::ImageData::fromPixels(swappedImage.bits(), bb::PixelFormat::RGBX, swappedImage.width(), swappedImage.height(), swappedImage.bytesPerLine());
m_image = bb::cascades::Image(imageData);
emit imageChanged();
m_loading = false;
emit loadingChanged();
}
void ImageLoader::onReplyFinished()
{
QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
QString response;
if (reply)
{
if (reply->error() == QNetworkReply::NoError)
{
const int available = reply->bytesAvailable();
if (available > 0)
{
const QByteArray data(reply->readAll());
// Setup the image processing thread
ImageProcessor *imageProcessor = new ImageProcessor(data);
QFuture<QImage> future = QtConcurrent::run(imageProcessor, &ImageProcessor::start);
// Invoke our onProcessingFinished slot after the processing has finished.
connect(&m_watcher, SIGNAL(finished()), this, SLOT(onImageProcessingFinished()));
// starts watching the given future
m_watcher.setFuture(future);
}
}
else
{
m_loading = false;
emit loadingChanged();
}
reply->deleteLater();
}
else
{
m_loading = false;
emit loadingChanged();
}
}
void WebImageView::setUrl(const QUrl url) {
if(url != mUrl){
resetImage();
mUrl = url;
QIODevice *temp = diskCache->data(url);
if(temp){
setImage(Image(temp->readAll()));
mLoading = 1;
emit loadingChanged();
} else{
mLoading = 0.01;
emit loadingChanged();
if(defaultImageUrl!=QUrl(""))
setImage(Image(defaultImageUrl));
urls.push_back(url);
replies.push_back(mNetManager->get(QNetworkRequest(url)));
connect(replies.back(),SIGNAL(finished()), this, SLOT(imageLoaded()));
connect(replies.back(),SIGNAL(downloadProgress ( qint64 , qint64 )), this, SLOT(downloadProgressed(qint64,qint64)));
}
emit urlChanged();
}
}
void ImageLoader::load()
{
m_loading = true;
emit loadingChanged();
QNetworkAccessManager* netManager = new QNetworkAccessManager(this);
const QUrl url(m_param5); // imageURL
QNetworkRequest request(url);
QNetworkReply* reply = netManager->get(request);
connect(reply, SIGNAL(finished()), this, SLOT(onReplyFinished()));
}
void ImageLoader::load()
{
m_loading = true;
emit loadingChanged();
qDebug() << "FMI ########## start loading " << m_imageUrl;
QNetworkAccessManager* networkAccessManager = new QNetworkAccessManager(this); // up to 6 connections at a time
const QUrl url(m_imageUrl);
QNetworkRequest request(url);
QNetworkReply* reply = networkAccessManager->get(request);
connect(reply, SIGNAL(finished()), this, SLOT(onReplyFinished()));
}
void ImageLoader::load() {
_loading = true;
emit loadingChanged();
QNetworkAccessManager* netManager = new QNetworkAccessManager(this);
const QUrl url(_imageUrl);
QNetworkRequest request(url);
QNetworkReply* reply = netManager->get(request);
if (Settings::getValueFor("ignoreSslErrors", QVariant(false)).toBool())
reply->ignoreSslErrors();
connect(reply, SIGNAL(finished()), this, SLOT(onReplyFinished()));
}
void MusicCollector::loadFromFetcher(MusicFetcher *fetcher)
{
if (currentReply) {
if (currentReply->isRunning())
currentReply->abort();
currentReply = 0;
emit loadingChanged();
}
idList.clear();
for (int i = 0; i < fetcher->count(); i++)
idList.append(fetcher->dataAt(i)->musicId().toInt());
emit dataChanged();
}
void FeedLoader::setSource(const QUrl& source) {
feedSource = source;
emit sourceChanged();
feedIsLoading = true;
emit loadingChanged();
feedData.clear();
emit dataChanged();
QNetworkRequest req(source);
req.setRawHeader("User-Agent", QString("JollaUsers reader/%1 (Sailfish OS)").arg(APP_VERSION).toUtf8());
qDebug() << "Requesting " << source << " as " << QString("JollaUsers reader/%1 (Sailfish OS)").arg(APP_VERSION).toUtf8();
myNetworkAccessManager->get(req);
}
void QtWebKitWebWidget::pageLoadFinished(bool ok)
{
if (!m_isLoading)
{
return;
}
m_isLoading = false;
m_thumbnail = QPixmap();
m_networkAccessManager->resetStatistics();
if (m_actions.contains(ReloadOrStopAction))
{
QAction *action = getAction(ReloadOrStopAction);
ActionsManager::setupLocalAction(action, QLatin1String("Reload"));
action->setShortcut(QKeySequence());
}
if (!isPrivate())
{
if (ok)
{
SessionsManager::markSessionModified();
if (m_historyEntry >= 0)
{
HistoryManager::updateEntry(m_historyEntry, getUrl(), m_webView->title(), m_webView->icon());
}
}
else if (m_historyEntry >= 0)
{
HistoryManager::removeEntry(m_historyEntry);
}
}
emit loadingChanged(false);
}
void HistoryContentsWidget::populateEntries()
{
const QDate date = QDate::currentDate();
QList<QDate> dates;
dates << date << date.addDays(-1) << date.addDays(-7) << date.addDays(-14) << date.addDays(-30) << date.addDays(-365);
for (int i = 0; i < m_model->rowCount(); ++i)
{
m_ui->historyView->setRowHidden(i, m_model->invisibleRootItem()->index(), true);
QStandardItem *groupItem = m_model->item(i, 0);
if (groupItem)
{
groupItem->setData(dates.value(i, QDate()), Qt::UserRole);
groupItem->removeRows(0, groupItem->rowCount());
}
}
const QList<HistoryEntry> entries = HistoryManager::getEntries();
for (int i = 0; i < entries.count(); ++i)
{
addEntry(entries.at(i));
}
for (int i = 0; i < m_model->rowCount(); ++i)
{
QStandardItem *groupItem = m_model->item(i, 0);
if (groupItem)
{
groupItem->sortChildren(2, Qt::DescendingOrder);
}
}
m_isLoading = false;
emit loadingChanged(false);
}
void MusicCollector::requestFinished()
{
sender()->deleteLater();
if (currentReply != sender())
return;
emit loadingChanged();
int nextOpt = nextOperation;
QString optId = operatingId;
nextOperation = OperationNone;
operatingId.clear();
if (currentReply->error() != QNetworkReply::NoError)
return;
QVariantMap resp = parser->parse(currentReply->readAll()).toMap();
if (resp.value("code", -1).toInt() != 200)
return;
int opt = currentReply->property(KeyOperation).toInt();
if (opt == OperationLoadPid) {
foreach (const QVariant& playlist, resp.value("playlist").toList()) {
QVariantMap map = playlist.toMap();
if (map.value("specialType").toInt() == 5) {
playlistId = map.value("id").toInt();
break;
}
}
if (playlistId == 0)
return;
if (nextOpt == OperationCollectMusic)
collectMusic(optId);
else if (nextOpt == OperationRemoveCollection)
removeCollection(optId);
else
loadList();
}
void MusicCollector::refresh()
{
QString uid = UserConfig::Instance()->getSetting(UserConfig::KeyUserId).toString();
if (uid.isEmpty())
return;
if (currentReply && currentReply->isRunning())
currentReply->abort();
QUrl url(QString(ApiBaseUrl).append("/user/playlist/"));
url.addEncodedQueryItem("offset", "0");
url.addEncodedQueryItem("limit", "1000");
url.addEncodedQueryItem("uid", uid.toAscii());
checkNAM();
currentReply = manager->get(QNetworkRequest(url));
currentReply->setProperty(KeyOperation, OperationLoadPid);
connect(currentReply, SIGNAL(finished()), SLOT(requestFinished()), Qt::QueuedConnection);
emit loadingChanged();
}
void QtWebKitWebWidget::pageLoadStarted()
{
m_isLoading = true;
m_thumbnail = QPixmap();
if (m_actions.contains(RewindBackAction))
{
getAction(RewindBackAction)->setEnabled(getAction(GoBackAction)->isEnabled());
}
if (m_actions.contains(RewindForwardAction))
{
getAction(RewindForwardAction)->setEnabled(getAction(GoForwardAction)->isEnabled());
}
if (m_actions.contains(ReloadOrStopAction))
{
QAction *action = getAction(ReloadOrStopAction);
ActionsManager::setupLocalAction(action, QLatin1String("Stop"));
action->setShortcut(QKeySequence());
action->setEnabled(true);
}
if (!isPrivate())
{
SessionsManager::markSessionModified();
m_historyEntry = HistoryManager::addEntry(getUrl(), m_webView->title(), m_webView->icon(), m_isTyped);
m_isTyped = false;
}
emit loadingChanged(true);
emit statusMessageChanged(QString());
}
void BookmarksContentsWidget::populateBookmarks()
{
const QList<BookmarkInformation*> bookmarks = BookmarksManager::getFolder();
for (int i = 0; i < bookmarks.count(); ++i)
{
addBookmark(bookmarks.at(i), m_model->invisibleRootItem());
}
m_ui->bookmarksView->setModel(m_model);
m_ui->bookmarksView->setItemDelegate(new ItemDelegate(this));
m_isLoading = false;
emit loadingChanged(false);
connect(BookmarksManager::getInstance(), SIGNAL(folderModified(int)), this, SLOT(updateFolder(int)));
connect(m_model, SIGNAL(modelReset()), this, SLOT(updateActions()));
connect(m_ui->filterLineEdit, SIGNAL(textChanged(QString)), this, SLOT(filterBookmarks(QString)));
connect(m_ui->bookmarksView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(openBookmark(QModelIndex)));
connect(m_ui->bookmarksView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showContextMenu(QPoint)));
connect(m_ui->bookmarksView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(updateActions()));
}
void WebImageView::imageLoaded() {
QNetworkReply * reply = qobject_cast<QNetworkReply*>(sender());
if (reply->error() == QNetworkReply::NoError) {
QVariant repliestatus = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
int i=replies.indexOf(reply);
// HANDLES REDIRECTIONS
if (repliestatus == 301 || repliestatus == 302)
{
QString redirectUrl = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toString();
replies[i]=mNetManager->get(QNetworkRequest(redirectUrl));
connect(replies[i],SIGNAL(finished()), this, SLOT(imageLoaded()));
connect(replies[i],SIGNAL(downloadProgress ( qint64 , qint64 )), this, SLOT(downloadProgressed(qint64,qint64)));
} else {
if(urls.at(i)==mUrl)
setImage(Image(reply->readAll()));
urls.removeAt(i);
replies.removeAt(i);
}
}
mLoading = 1;
emit loadingChanged();
reply->deleteLater();
}
/**
* ImageLoader::onImageProcessingFinished(const QImage&)
*
* Handler for the signal indicating the result of the image processing.
*/
void ImageLoader::onImageProcessingFinished(const QImage &image)
{
try
{
if (!image.isNull()) {
if (image.size().height() > 0) {
m_image = bb::cascades::Image(fromQImage(image));
}
emit imageChanged();
m_label.clear();
emit labelChanged();
}
m_loading = false;
emit loadingChanged();
}
catch (...)
{
qDebug() << "FMI ##### AAAAAAAAAAAAAAAAAAAAAAAAAAAAAHHHHH!!!!";
}
}
void CookiesContentsWidget::populateCookies()
{
CookieJar *cookieJar = qobject_cast<CookieJar*>(NetworkManagerFactory::getCookieJar());
const QList<QNetworkCookie> cookies = cookieJar->getCookies();
for (int i = 0; i < cookies.count(); ++i)
{
addCookie(cookies.at(i));
}
m_model->sort(0);
m_ui->cookiesView->setModel(m_model);
m_isLoading = false;
emit loadingChanged(false);
connect(cookieJar, SIGNAL(cookieAdded(QNetworkCookie)), this, SLOT(addCookie(QNetworkCookie)));
connect(cookieJar, SIGNAL(cookieRemoved(QNetworkCookie)), this, SLOT(removeCookie(QNetworkCookie)));
connect(m_model, SIGNAL(modelReset()), this, SLOT(updateActions()));
connect(m_ui->cookiesView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(updateActions()));
}
bool DeclarativeWebContainer::activatePage(int tabId, bool force, int parentId)
{
if (!m_model) {
return false;
}
m_webPages->initialize(this, m_webPageComponent.data());
if ((m_model->loaded() || force) && tabId > 0 && m_webPages->initialized()) {
WebPageActivationData activationData = m_webPages->page(tabId, parentId);
setWebPage(activationData.webPage);
// Reset always height so that orentation change is taken into account.
m_webPage->forceChrome(false);
m_webPage->setChrome(true);
connect(m_webPage, SIGNAL(imeNotification(int,bool,int,int,QString)),
this, SLOT(imeNotificationChanged(int,bool,int,int,QString)), Qt::UniqueConnection);
connect(m_webPage, SIGNAL(windowCloseRequested()), this, SLOT(closeWindow()), Qt::UniqueConnection);
connect(m_webPage, SIGNAL(urlChanged()), this, SLOT(onPageUrlChanged()), Qt::UniqueConnection);
connect(m_webPage, SIGNAL(loadingChanged()), this, SLOT(updateLoading()), Qt::UniqueConnection);
connect(m_webPage, SIGNAL(loadProgressChanged()), this, SLOT(updateLoadProgress()), Qt::UniqueConnection);
connect(m_webPage, SIGNAL(titleChanged()), this, SLOT(onPageTitleChanged()), Qt::UniqueConnection);
connect(m_webPage, SIGNAL(domContentLoadedChanged()), this, SLOT(sendVkbOpenCompositionMetrics()), Qt::UniqueConnection);
connect(m_webPage, SIGNAL(backgroundChanged()), this, SIGNAL(backgroundChanged()), Qt::UniqueConnection);
return activationData.activated;
}
void TransfersContentsWidget::updateTransfer(Transfer *transfer)
{
const int row = findTransfer(transfer);
if (row < 0)
{
return;
}
QString remainingTime;
if (transfer->getState() == Transfer::RunningState)
{
if (!m_speeds.contains(transfer))
{
m_speeds[transfer] = QQueue<qint64>();
}
m_speeds[transfer].enqueue(transfer->getSpeed());
if (m_speeds[transfer].count() > 10)
{
m_speeds[transfer].dequeue();
}
if (transfer->getBytesTotal() > 0)
{
qint64 speedSum = 0;
const QList<qint64> speeds = m_speeds[transfer];
for (int i = 0; i < speeds.count(); ++i)
{
speedSum += speeds.at(i);
}
speedSum /= (speeds.count());
remainingTime = Utils::formatTime(qreal(transfer->getBytesTotal() - transfer->getBytesReceived()) / speedSum);
}
}
else
{
m_speeds.remove(transfer);
}
QIcon icon;
switch (transfer->getState())
{
case Transfer::RunningState:
icon = Utils::getIcon(QLatin1String("task-ongoing"));
break;
case Transfer::FinishedState:
icon = Utils::getIcon(QLatin1String("task-complete"));
break;
default:
icon = Utils::getIcon(QLatin1String("task-reject"));
break;
}
m_model->item(row, 0)->setIcon(icon);
m_model->item(row, 1)->setText(QFileInfo(transfer->getTarget()).fileName());
m_model->item(row, 2)->setText(Utils::formatUnit(transfer->getBytesTotal(), false, 1));
m_model->item(row, 3)->setText((transfer->getBytesTotal() > 0) ? QString::number(qFloor((static_cast<qreal>(transfer->getBytesReceived()) / transfer->getBytesTotal()) * 100), 'f', 0) : QString());
m_model->item(row, 4)->setText(remainingTime);
m_model->item(row, 5)->setText((transfer->getState() == Transfer::RunningState) ? Utils::formatUnit(transfer->getSpeed(), true, 1) : QString());
m_model->item(row, 6)->setText(transfer->getTimeStarted().toString(QLatin1String("yyyy-MM-dd HH:mm:ss")));
m_model->item(row, 7)->setText(transfer->getTimeFinished().toString(QLatin1String("yyyy-MM-dd HH:mm:ss")));
const QString tooltip = tr("<div style=\"white-space:pre;\">Source: %1\nTarget: %2\nSize: %3\nDownloaded: %4\nProgress: %5</div>").arg(transfer->getSource().toString().toHtmlEscaped()).arg(transfer->getTarget().toHtmlEscaped()).arg(Utils::formatUnit(transfer->getBytesTotal(), false, 1, true)).arg(Utils::formatUnit(transfer->getBytesReceived(), false, 1, true)).arg(QStringLiteral("%1%").arg(((transfer->getBytesTotal() > 0) ? ((static_cast<qreal>(transfer->getBytesReceived()) / transfer->getBytesTotal()) * 100) : 0.0), 0, 'f', 1));
for (int i = 0; i < m_model->columnCount(); ++i)
{
m_model->item(row, i)->setToolTip(tooltip);
}
if (m_ui->transfersViewWidget->selectionModel()->hasSelection())
{
updateActions();
}
const bool isRunning = (transfer && transfer->getState() == Transfer::RunningState);
if (isRunning != m_isLoading)
{
if (isRunning)
{
m_isLoading = true;
emit loadingChanged(true);
}
else
{
const QList<Transfer*> transfers = TransfersManager::getTransfers();
bool hasRunning = false;
for (int i = 0; i < transfers.count(); ++i)
{
if (transfers.at(i) && transfers.at(i)->getState() == Transfer::RunningState)
{
hasRunning = true;
break;
}
}
if (!hasRunning)
{
m_isLoading = false;
emit loadingChanged(false);
}
}
}
}
