yacreader/YACReaderLibrary/comic_flow.cpp

#include "comic_flow.h"
#include "qnaturalsorting.h"

#include "yacreader_global.h"

#include <algorithm>

#include <QMutex>
#include <QImageReader>
#include <QTimer>

ComicFlow::ComicFlow(QWidget* parent,FlowType flowType)
:YACReaderFlow(parent,flowType)
{
	updateTimer = new QTimer;
	connect(updateTimer, SIGNAL(timeout()), this, SLOT(updateImageData()));

	worker = new ImageLoader;
	connect(this, SIGNAL(centerIndexChanged(int)), this, SLOT(preload()));
	connect(this, SIGNAL(centerIndexChangedSilent(int)), this, SLOT(preload()));

	setReflectionEffect(PlainReflection);
}

ComicFlow::~ComicFlow()
{
    worker->terminate();
	delete worker;
	delete updateTimer;
}

void ComicFlow::setImagePaths(const QStringList& paths)
{
	clear();

	//imagePath = path;
	imageFiles = paths;
	imagesLoaded.clear();
	imagesLoaded.fill(false,imageFiles.size());
	numImagesLoaded = 0;

	imagesSetted.clear();
	imagesSetted.fill(false,imageFiles.size());

	// populate with empty images
	QImage img; //TODO remove
	QString s;
	for(int i = 0; i < (int)imageFiles.size(); i++)
	{
		addSlide(img);
		s = imageFiles.at(i);
		s.remove(s.size()-4,4);
		if(QFileInfo(s+".r").exists())
			markSlide(i);
	}

	setCenterIndex(0);
	worker->reset();
	preload();
}

void ComicFlow::preload()
{
	if(numImagesLoaded < imagesLoaded.size())
		updateTimer->start(30); //TODO comprobar rendimiento, originalmente era 70
}

void ComicFlow::updateImageData()
{
	// can't do anything, wait for the next possibility
	if(worker->busy())
		return;

	// set image of last one
	int idx = worker->index();
	if( idx >= 0 && !worker->result().isNull())
	{
		if(!imagesSetted[idx])
		{
			setSlide(idx, worker->result());
			imagesSetted[idx] = true;
			numImagesLoaded++;
			imagesLoaded[idx]=true;
		}
	}

	// try to load only few images on the left and right side 
	// i.e. all visible ones plus some extra
#define COUNT 8  
	int indexes[2*COUNT+1];
	int center = centerIndex();
	indexes[0] = center;
	for(int j = 0; j < COUNT; j++)
	{
		indexes[j*2+1] = center+j+1;
		indexes[j*2+2] = center-j-1;
	}  
	for(int c = 0; c < 2*COUNT+1; c++)
	{
		int i = indexes[c];
		if((i >= 0) && (i < slideCount()))
			if(!imagesLoaded[i])//slide(i).isNull())
			{
				// schedule thumbnail generation
				QString fname = imageFiles[i];
				
				
				worker->generate(i, fname, slideSize());
				return;
			}
	}

	// no need to generate anything? stop polling...
	updateTimer->stop();
}

void ComicFlow::keyPressEvent(QKeyEvent* event)
{
	PictureFlow::keyPressEvent(event);  
}

void ComicFlow::wheelEvent(QWheelEvent * event)
{
	if(event->delta()<0)
		showNext();
	else
		showPrevious();
	event->accept();
}

void ComicFlow::removeSlide(int cover)
{
	worker->lock();

	worker->reset();

	imageFiles.removeAt(cover);
	if(imagesLoaded[cover])
		numImagesLoaded--;
	imagesLoaded.remove(cover);
	imagesSetted.remove(cover);

	YACReaderFlow::removeSlide(cover);
	worker->unlock();

    preload();
}

void ComicFlow::resortCovers(QList<int> newOrder)
{
    worker->lock();
    worker->reset();

    YACReaderFlow::resortCovers(newOrder);

    QStringList imageFilesNew;
    QVector<bool> imagesLoadedNew;
    QVector<bool> imagesSettedNew;
    foreach(int index, newOrder)
    {
        imageFilesNew << imageFiles.at(index);
        imagesLoadedNew << imagesLoaded.at(index);
        imagesSettedNew << imagesSetted.at(index);
    }



    imageFiles = imageFilesNew;
    imagesLoaded = imagesLoadedNew;
    imagesSetted = imagesSettedNew;

    worker->unlock();
}
//-----------------------------------------------------------------------------
//ImageLoader
//-----------------------------------------------------------------------------
static QImage loadImage(const QString& fileName)
{
	QImage image;
	bool result = image.load(fileName);

	if(!result)
		return QImage();

	return image;
}

ImageLoader::ImageLoader(): 
QThread(), restart(false), working(false), idx(-1)
{
}

ImageLoader::~ImageLoader()
{
	mutex.lock();
	condition.wakeOne();
	mutex.unlock();
	wait();
}

bool ImageLoader::busy() const
{
	return isRunning() ? working : false;
}  

void ImageLoader::generate(int index, const QString& fileName, QSize size)
{
	mutex.lock();
	this->idx = index;
	this->fileName = fileName;
	this->size = size;
	this->img = QImage();
	mutex.unlock();

	if (!isRunning())
		start();
	else
	{
		// already running, wake up whenever ready
		restart = true;
		condition.wakeOne();
	}
}

void ImageLoader::lock()
{
	mutex.lock();
}

void ImageLoader::unlock()
{
	mutex.unlock();
}

void ImageLoader::run()
{
	for(;;)
	{
		// copy necessary data
		mutex.lock();
		this->working = true;
		QString fileName = this->fileName;
		mutex.unlock();

		QImage image = loadImage(fileName);

		// let everyone knows it is ready
		mutex.lock();
		this->working = false;
		this->img = image;
		mutex.unlock();

		// put to sleep
		mutex.lock();
		if (!this->restart)
			condition.wait(&mutex);
		restart = false;
		mutex.unlock();
	}
}

QImage ImageLoader::result() 
{ 
	return img; 
}