UrlLoader::UrlLoader(BrowserWindow* browserWindow, const QString& inputFileName, int timeoutSeconds, int extraTimeSeconds)
: m_browserWindow(browserWindow)
, m_stdOut(stdout)
, m_loaded(0)
, m_numFramesLoading(0)
{
m_checkIfFinishedTimer.setInterval(200);
m_checkIfFinishedTimer.setSingleShot(true);
connect(&m_checkIfFinishedTimer, SIGNAL(timeout()), this, SLOT(checkIfFinished()));
// loadStarted and loadFinished on QWebPage is emitted for each frame/sub-frame
connect(m_browserWindow->webView(), SIGNAL(loadStarted()), this, SLOT(frameLoadStarted()));
connect(m_browserWindow->webView(), SIGNAL(loadFinished(bool)), this, SLOT(frameLoadFinished()));
if (timeoutSeconds) {
m_timeoutTimer.setInterval(timeoutSeconds * 1000);
m_timeoutTimer.setSingleShot(true);
connect(m_browserWindow->webView(), SIGNAL(loadStarted()), &m_timeoutTimer, SLOT(start()));
connect(&m_timeoutTimer, SIGNAL(timeout()), this, SLOT(loadNext()));
}
if (extraTimeSeconds) {
m_extraTimeTimer.setInterval(extraTimeSeconds * 1000);
m_extraTimeTimer.setSingleShot(true);
connect(this, SIGNAL(pageLoadFinished()), &m_extraTimeTimer, SLOT(start()));
connect(&m_extraTimeTimer, SIGNAL(timeout()), this, SLOT(loadNext()));
} else
connect(this, SIGNAL(pageLoadFinished()), this, SLOT(loadNext()));
loadUrlList(inputFileName);
}
void Musec::mediaStatusChanged(quint8 status)
{
qDebug() << fPlayer->mediaStatus();
if (status == QMediaPlayer::InvalidMedia) {
loadNext();
return;
}
if (status == QMediaPlayer::NoMedia) {
btnPlay->setDisabled(true);
statusbar->showMessage(tr("No songs left"));
return;
}
if (status == QMediaPlayer::BufferedMedia) {
fPlayer->setPosition(fStartTime * 1000);
return;
}
if (status != QMediaPlayer::LoadedMedia || fStartTime >= 0)
return;
// Refresh data
qint64 duration = fPlayer->duration();
fScore->updateMultiplier(slDifficulty->value(), fPlaylist->mediaCount());
statusbar->showMessage(tr("Played: %1 (%2 in queue)").arg(
fScore->played()).arg(fPlaylist->mediaCount()));
// Skip if too short (<30s)
if (duration <= 30000) {
qDebug() << "SKIP: Too short!";
loadNext();
return;
}
// Skip songs without all tags
QString title = fPlayer->metaData(QMediaMetaData::Title).toString();
QString artist = fPlayer->metaData(QMediaMetaData::Author).toString();
QString album = fPlayer->metaData(QMediaMetaData::AlbumTitle).toString();
if (title.isEmpty() || artist.isEmpty() || album.isEmpty()) {
qDebug() << "SKIP: No tags!";
loadNext();
return;
}
qDebug() << title << "-" << artist << "-" << album;
// Generate start time
duration /= 1000;
qint64 startRange = duration * 0.1f;
qint64 timeRange = duration * 0.8f;
qint64 random = qrand() % timeRange;
fStartTime = startRange + random;
btnPlay->setEnabled(true);
}
void kCallBack(char ch)
{
switch(ch)
{
case ' ':
saveDataFile(file_set[cur_file_ptr]);
loadNext();
break;
case '\n':
saveDataFile(file_set[cur_file_ptr]);
loadPrevious();
break;
case 'p':
loadPrevious();
break;
case 'q':
exitLBT();
break;
case 'n':
loadNext();
break;
case '=':
nextPoint();
showImage();
break;
case '-':
previousPoint();
showImage();
break;
case '[':
previousAttrVal();
showImage();
break;
case ']':
nextAttrVal();
showImage();
break;
case 'c':
if(lb_type==TYPE_SQR)
{
saveSQR();
}
}
if(ch>='0'&&ch<='9'&&lb_type==TYPE_DEG)
{
degree = ch-'0';
printf("%c\n",ch);
showImage();
}
}
void Musec::on_btnNext_clicked()
{
fPlayer->stop();
resetForm();
evaluate();
loadNext();
}
void Downloader::getPageCount()
{
if (m_sites->empty())
{
std::cerr << "No valid source found" << std::endl;
return;
}
m_waiting = 0;
m_ignored = 0;
m_duplicates = 0;
m_cancelled = false;
auto sites = Site::getAllSites();
for (int i = 0; i < m_sites->size(); ++i)
{
Page *page = new Page(m_sites->at(i), sites, m_tags, m_page, m_perpage, m_postfiltering, true, this);
connect(page, &Page::finishedLoadingTags, this, &Downloader::finishedLoadingPageCount);
m_pagesC->append(page);
m_opagesC->append(page);
m_waiting++;
}
loadNext();
}
void mtpFileLoader::localLoaded(const StorageImageSaved &result, const QByteArray &imageFormat, const QPixmap &imagePixmap) {
_localTaskId = 0;
if (result.type == StorageFileUnknown) {
_localStatus = LocalFailed;
start(true);
return;
}
data = result.data;
type = mtpFromStorageType(result.type);
if (!imagePixmap.isNull()) {
_imageFormat = imageFormat;
_imagePixmap = imagePixmap;
}
_localStatus = LocalLoaded;
if (!fname.isEmpty() && duplicateInData) {
if (!fileIsOpen) fileIsOpen = file.open(QIODevice::WriteOnly);
if (!fileIsOpen) {
finishFail();
return;
}
if (file.write(data) != qint64(data.size())) {
finishFail();
return;
}
}
complete = true;
if (fileIsOpen) {
file.close();
fileIsOpen = false;
psPostprocessFile(QFileInfo(file).absoluteFilePath());
}
emit App::wnd()->imageLoaded();
emit progress(this);
loadNext();
}
void mtpFileLoader::partLoaded(int32 offset, const MTPupload_File &result) {
if (requestId) {
--queue->queries;
requestId = 0;
}
if (offset == currentOffset()) {
int32 limit = locationType ? DocumentDownloadPartSize : DownloadPartSize;
const MTPDupload_file &d(result.c_upload_file());
const string &bytes(d.vbytes.c_string().v);
if (bytes.size()) {
if (file.isOpen()) {
if (file.write(bytes.data(), bytes.size()) != qint64(bytes.size())) {
return finishFail();
}
} else {
data.append(bytes.data(), bytes.size());
}
}
if (bytes.size() && !(bytes.size() % 1024)) { // good next offset
// offset += bytes.size();
} else {
type = d.vtype;
complete = true;
if (file.isOpen()) {
file.close();
psPostprocessFile(QFileInfo(file).absoluteFilePath());
}
removeFromQueue();
App::wnd()->update();
App::wnd()->psUpdateNotifies();
}
emit progress(this);
}
loadNext();
}
void Downloader::getTags()
{
if (m_sites->empty())
{
std::cerr << "No valid source found" << std::endl;
return;
}
m_waiting = 0;
m_cancelled = false;
for (int i = 0; i < m_sites->size(); ++i)
{
int pages = qCeil((float)m_max / m_perpage);
if (pages <= 0 || m_perpage <= 0 || m_max <= 0)
pages = 1;
Site *site = m_sites->at(i);
connect(site, &Site::finishedLoadingTags, this, &Downloader::finishedLoadingTags);
for (int p = 0; p < pages; ++p)
{
m_pagesP->append(QPair<Site*, int>(site, m_page + p));
m_opagesP->append(QPair<Site*, int>(site, m_page + p));
m_waiting++;
}
}
loadNext();
}
void webFileLoader::onFinished(const QByteArray &data) {
if (_fileIsOpen) {
if (_file.write(data.constData(), data.size()) != qint64(data.size())) {
return cancel(true);
}
} else {
_data = data;
}
if (!_fname.isEmpty() && (_toCache == LoadToCacheAsWell)) {
if (!_fileIsOpen) _fileIsOpen = _file.open(QIODevice::WriteOnly);
if (!_fileIsOpen) {
return cancel(true);
}
if (_file.write(_data) != qint64(_data.size())) {
return cancel(true);
}
}
_type = mtpc_storage_filePartial;
_complete = true;
if (_fileIsOpen) {
_file.close();
_fileIsOpen = false;
psPostprocessFile(QFileInfo(_file).absoluteFilePath());
}
removeFromQueue();
if (_localStatus == LocalNotFound || _localStatus == LocalFailed) {
Local::writeWebFile(_url, _data);
}
emit progress(this);
FileDownload::ImageLoaded().notify();
loadNext();
}
void BatchLoader::loadAll()
{
if(!loading)
{
if(eventListeners.size()>0)
{
ArrayList<BatchLoaderEventListener*> listeners = eventListeners;
for(unsigned int i = 0; i < listeners.size(); i++)
{
BatchLoaderEventListener*listener = listeners.get(i);
listener->onBatchLoaderStart(this);
}
}
loading = true;
while(loadindex<loadlist.size() && loading)
{
loadNext();
loadindex++;
}
loading = false;
if(loadindex == (loadlist.size()-1))
{
ArrayList<BatchLoaderEventListener*> listeners = eventListeners;
for(unsigned int i = 0; i < listeners.size(); i++)
{
BatchLoaderEventListener*listener = listeners.get(i);
listener->onBatchLoaderFinish(this);
}
}
}
}
void Downloader::finishedLoadingImage(Image *image)
{
if (m_cancelled)
return;
log("Received image '"+image->url()+"'");
if (m_quit)
{
QStringList paths = image->path(m_filename, m_location);
for (QString path : paths)
{
path = (m_location.endsWith('/') ? m_location.left(m_location.length() - 1) : m_location) + "/" + (path.startsWith('/') ? path.right(path.length() - 1) : path);
QFile f(QDir::toNativeSeparators(path));
if (f.open(QFile::WriteOnly))
{
f.write(image->data());
f.close();
log("Saved to '"+path+"'");
}
}
}
else
emit finishedImage(image);
if (--m_waiting > 0)
{
loadNext();
return;
}
if (m_quit)
returnString("Downloaded images successfully.");
}
void Downloader::getUrls()
{
if (m_sites->empty())
{
std::cerr << "No valid source found" << std::endl;
return;
}
m_waiting = 0;
m_ignored = 0;
m_duplicates = 0;
m_cancelled = false;
auto sites = Site::getAllSites();
for (int i = 0; i < m_sites->size(); ++i)
{
int pages = qCeil((float)m_max / m_perpage);
if (pages <= 0 || m_perpage <= 0 || m_max <= 0)
pages = 1;
for (int p = 0; p < pages; ++p)
{
Page *page = new Page(m_sites->at(i), sites, m_tags, m_page + p, m_perpage, m_postfiltering, true, this);
connect(page, &Page::finishedLoading, this, &Downloader::finishedLoadingUrls);
m_pages->append(page);
m_opages->append(page);
m_waiting++;
}
}
loadNext();
}
void Downloader::downloadImages(QList<Image*> images)
{
m_images->clear();
m_images->append(images);
m_waiting = images.size();
loadNext();
}
void RenameExisting1::getTags()
{
Image *img = dynamic_cast<Image*>(sender());
m_getAll[img->md5()].second = img->path(ui->lineFilenameDestination->text(), ui->lineFolder->text(), 0, true, false, true, true, true).first();
ui->progressBar->setValue(ui->progressBar->value() + 1);
loadNext();
}
bool mtpFileLoader::tryLoadLocal() {
if (_localStatus == LocalNotFound || _localStatus == LocalLoaded || _localStatus == LocalFailed) {
return false;
}
if (_localStatus == LocalLoading) {
return true;
}
if (_locationType == UnknownFileLocation) {
_localTaskId = Local::startImageLoad(storageKey(dc, volume, local), this);
if (_localTaskId) {
_localStatus = LocalLoading;
return true;
}
} else {
if (duplicateInData) {
MediaKey mkey = mediaKey(_locationType, dc, id);
if (_locationType == DocumentFileLocation) {
_localTaskId = Local::startStickerImageLoad(mkey, this);
} else if (_locationType == AudioFileLocation) {
_localTaskId = Local::startAudioLoad(mkey, this);
}
}
}
if (data.isEmpty()) {
_localStatus = LocalNotFound;
return false;
}
_localStatus = LocalLoaded;
if (!fname.isEmpty() && duplicateInData) {
if (!fileIsOpen) fileIsOpen = file.open(QIODevice::WriteOnly);
if (!fileIsOpen) {
finishFail();
return true;
}
if (file.write(data) != qint64(data.size())) {
finishFail();
return true;
}
}
complete = true;
if (fileIsOpen) {
file.close();
fileIsOpen = false;
psPostprocessFile(QFileInfo(file).absoluteFilePath());
}
emit App::wnd()->imageLoaded();
emit progress(this);
loadNext();
return true;
}
void UrlLoader::loadNext()
{
QString qstr;
if (getUrl(qstr)) {
QUrl url(qstr, QUrl::StrictMode);
if (url.isValid()) {
m_stdOut << "Loading " << qstr << " ......" << ++m_loaded << endl;
m_frame->load(url);
} else
loadNext();
} else
disconnect(m_frame, 0, this, 0);
}
void mtpFileLoader::cancel() {
cancelRequests();
type = mtpc_storage_fileUnknown;
complete = true;
if (fileIsOpen) {
file.close();
fileIsOpen = false;
file.remove();
}
data = QByteArray();
file.setFileName(QString());
emit progress(this);
loadNext();
}
void Downloader::finishedLoadingUrls(Page *page)
{
if (m_cancelled)
return;
log("Received page '"+page->url().toString()+"'");
emit finishedUrlsPage(page);
if (--m_waiting > 0)
{
loadNext();
return;
}
QList<Image*> images;
for (int i = 0; i < m_pages->size(); ++i)
for (Image *img : m_pages->at(i)->images())
{
if (!m_blacklist)
{
if (!img->blacklisted(m_blacklistedTags).empty())
{
++m_ignored;
continue;
}
}
if (m_noduplicates)
{
bool found = false;
for (Image *image : images)
if (image->md5() == img->md5())
found = true;
if (found)
continue;
}
images.append(img);
}
QStringList urls;
int i = 0;
for (Image *img : images)
if (m_max <= 0 || i++ < m_max)
urls.append(img->url());
if (m_quit)
returnStringList(urls);
else
emit finishedUrls(urls);
}
void mtpFileLoader::finishFail() {
bool started = currentOffset(true) > 0;
cancelRequests();
type = mtpc_storage_fileUnknown;
complete = true;
if (fileIsOpen) {
file.close();
fileIsOpen = false;
file.remove();
}
data = QByteArray();
emit failed(this, started);
file.setFileName(fname = QString());
loadNext();
}
void mtpFileLoader::finishFail() {
bool started = currentOffset() > 0;
if (requestId) {
requestId = 0;
--queue->queries;
}
type = MTP_storage_fileUnknown();
complete = true;
if (file.isOpen()) {
file.close();
file.remove();
}
data = QByteArray();
emit failed(this, started);
file.setFileName(QString());
loadNext();
}
void UrlLoader::loadNext()
{
m_timeoutTimer.stop();
m_extraTimeTimer.stop();
m_checkIfFinishedTimer.stop();
m_numFramesLoading = 0;
QString qstr;
if (getUrl(qstr)) {
QUrl url(qstr, QUrl::StrictMode);
if (url.isValid()) {
m_stdOut << "Loading " << qstr << " ......" << ++m_loaded << endl;
m_browserWindow->load(url.toString());
} else
loadNext();
} else
disconnect(m_browserWindow, 0, this, 0);
}
void User::loadAnimeData(Anime *anime, bool download_cover) {
int queue_size = queue.size();
if (db->loadAnime(anime)) {
return;
}
QMap<Anime *, bool> data;
data.insert(anime, download_cover);
queue.push(data);
if (queue_size == 0) {
async_registry.append(QtConcurrent::run([&, this]() { // NOLINT
return loadNext();
}));
}
}
void
ImageView::handleImageReady(const QString &fname, const QPixmap &image,
const QSize &splits)
{
ImageItem **ptr = &m_loadQueue;
printf("ImageView::handleImageReady(%s,%s)\n",
(const char*)fname.utf8(),
image.isNull()?"NULL":"VALID");
while (*ptr) {
if ((*ptr)->m_filename==fname) {
break;
}
ptr = &(*ptr)->m_next;
}
if (NULL==*ptr) {
checkAndStartLoader(m_filename);
return;
}
if ((*ptr)->m_status==ImageItem::WAITING) {
ImageItem *todel = *ptr;
*ptr = todel->m_next;
m_queueSize -= 1;
if (image.isNull()) {
emit loadNext();
return;
} else {
setImage(image, splits);
repaint(false);
}
delete todel;
} else {
if (image.isNull()) {
(*ptr)->m_status = ImageItem::FAILED;
} else {
(*ptr)->m_image = image;
(*ptr)->m_splits = splits;
(*ptr)->m_status = ImageItem::LOADED;
}
}
checkAndStartLoader(m_filename);
}
void Musec::on_actAddFiles_triggered()
{
statusbar->showMessage(tr("Loading..."));
// Add music files to playlist
QStringList files = QFileDialog::getOpenFileNames(this, tr("Select Files"),
getConfig("music/dir", QDir::homePath()), "Music (" + fExtensions.join(" ") + ")");
if (files.isEmpty()) {
statusbar->clearMessage();
return;
}
setConfig("music/dir", QFileInfo(files[0]).absolutePath());
for (int i = 0; i < files.size(); i++)
fPlaylist->addMedia(QUrl::fromLocalFile(files.at(i)));
fPlaylist->shuffle();
loadNext(false);
}
void
ImageView::nextPage()
{
int xoff, yoff, xsl, ysl;
xoff = m_xoffset;
yoff = m_yoffset;
xsl = m_xslice;
ysl = m_yslice;
switch (m_scrollMode) {
case IVPM_DOWN_RIGHT:
if (scrollDown() || scrollRight()) return;
break;
case IVPM_DOWN_LEFT:
if (scrollDown() || scrollLeft()) return;
break;
case IVPM_RIGHT_DOWN:
if (scrollRight() || scrollDown()) return;
break;
case IVPM_LEFT_DOWN:
if (scrollLeft() || scrollDown()) return;
break;
}
switch (m_pageMode) {
case IVPM_RIGHT_DOWN:
if (rightSlice() || downSlice()) return;
break;
case IVPM_LEFT_DOWN:
if (leftSlice() || downSlice()) return;
break;
case IVPM_DOWN_RIGHT:
if (downSlice() || rightSlice()) return;
break;
case IVPM_DOWN_LEFT:
if (downSlice() || leftSlice()) return;
break;
}
m_xoffset = xoff;
m_yoffset = yoff;
m_xslice = xsl;
m_yslice = ysl;
emit loadNext();
}
void FileLoader::cancel(bool fail) {
bool started = currentOffset(true) > 0;
cancelRequests();
_type = mtpc_storage_fileUnknown;
_complete = true;
if (_fileIsOpen) {
_file.close();
_fileIsOpen = false;
_file.remove();
}
_data = QByteArray();
if (fail) {
emit failed(this, started);
} else {
emit progress(this);
}
_fname = QString();
_file.setFileName(_fname);
loadNext();
}
void Downloader::finishedLoadingPageCount(Page *page)
{
if (m_cancelled)
return;
log("Received page '"+page->url().toString()+"'");
if (--m_waiting > 0)
{
loadNext();
return;
}
int total = 0;
for (int i = 0; i < m_pagesC->size(); ++i)
total += m_pagesC->at(i)->imagesCount();
if (m_quit)
returnInt(total);
else
emit finishedPageCount(total);
}
void Downloader::finishedLoadingPageTags(Page *page)
{
if (m_cancelled)
return;
log("Received tags '"+page->url().toString()+"'");
if (--m_waiting > 0)
{
loadNext();
return;
}
QList<Tag> list;
for (int i = 0; i < m_pagesT->size(); ++i)
for (Tag tag : m_pagesT->at(i)->tags())
{
bool found = false;
for (int j = 0; j < list.size(); ++j)
if (list[j].text() == tag.text())
{
list[j].setCount(list[j].count() + tag.count());
found = true;
}
if (!found)
list.append(tag);
}
QMutableListIterator<Tag> i(list);
while (i.hasNext())
if (i.next().count() < m_tagsmin)
i.remove();
if (m_quit)
returnTagList(list);
else
emit finishedTags(list);
}
void RenameExisting1::getAll(Page *p)
{
if (!p->images().isEmpty())
{
QSharedPointer<Image> img = p->images().at(0);
if (m_needDetails)
{
m_getTags.append(img);
}
else
{
m_getAll[img->md5()].second = img->path(ui->lineFilenameDestination->text(), ui->lineFolder->text(), 0, true, false, true, true, true).first();
ui->progressBar->setValue(ui->progressBar->value() + 1);
}
}
else
{
ui->progressBar->setValue(ui->progressBar->value() + 1);
}
loadNext();
}
void Downloader::finishedLoadingTags(QList<Tag> tags)
{
if (m_cancelled)
return;
log("Received pure tags");
m_results->append(tags);
if (--m_waiting > 0)
{
loadNext();
return;
}
QMutableListIterator<Tag> i(*m_results);
while (i.hasNext())
if (i.next().count() < m_tagsmin)
i.remove();
if (m_quit)
returnTagList(*m_results);
else
emit finishedTags(*m_results);
}
