mirror/yacreader
1
0
Fork 0
mirror of https://github.com/YACReader/yacreader synced 2025-06-04 01:28:55 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Modificada la clase Comic por una jerarqu?a y una factory

Browse Source 
corregido bug en go_to_flow_gl
This commit is contained in:
Luis Ángel San Martín 2013-01-19 23:16:32 +01:00
parent 753dba50df
commit eae74073c0
13 changed files with 335 additions and 525 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

558
YACReader/comic.cpp
View File

@ -18,19 +18,15 @@ Comic::Comic()
setup();
}
//-----------------------------------------------------------------------------
Comic::Comic(const QString pathFile)
Comic::Comic(const QString & pathFile)
:_pages(),_index(0),_path(pathFile),_loaded(false),bm(new Bookmarks()),_loadedPages(),_isPDF(false)
{
setup();
loadFromFile(pathFile);
}
//-----------------------------------------------------------------------------
Comic::~Comic()
{
//QThread::~QThread();
/*delete _7z;
delete _7ze;
delete bm;*/ //TODO safe delete
delete bm; //TODO safe delete
}
//-----------------------------------------------------------------------------
void Comic::setup()
@ -40,243 +36,6 @@ void Comic::setup()
connect(this,SIGNAL(imageLoaded(int)),this,SLOT(setPageLoaded(int)));
}
//-----------------------------------------------------------------------------
bool Comic::load(const QString & path)
{
QFileInfo fi(path);
if(fi.exists())
{
bm->newComic(path);
emit bookmarksLoaded(*bm);
if(fi.isFile())
{
if(fi.suffix().compare("pdf",Qt::CaseInsensitive) == 0)
{
_isPDF = true;
loadFromPDF(path);
}
else
loadFromFile(path);
}
else
{
if(fi.isDir())
{
loadFromDir(path);
}
}
return true;
}
else
{
QMessageBox::critical(NULL,tr("Not found"),tr("Comic not found"));
emit errorOpening();
return false;
}
}
//-----------------------------------------------------------------------------
void Comic::loadFromFile(const QString & pathFile)
{
_path = QDir::cleanPath(pathFile);
//load files size
_7z = new QProcess();
QStringList attributes;
attributes << "l" << "-ssc-" << "-r" << _path EXTENSIONS;
connect(_7z,SIGNAL(finished(int,QProcess::ExitStatus)),this,SLOT(loadSizes(void)));
connect(_7z,SIGNAL(error(QProcess::ProcessError)),this,SLOT(openingError(QProcess::ProcessError)));
_7z->start(QCoreApplication::applicationDirPath()+"/utils/7z",attributes);
}
//-----------------------------------------------------------------------------
void Comic::loadFromDir(const QString & pathDir)
{
_pathDir = pathDir;
start();
}
//-----------------------------------------------------------------------------
void Comic::loadFromPDF(const QString & pathPdf)
{
_path = pathPdf;
start();
}
//-----------------------------------------------------------------------------
void Comic::run()
{
if(_isPDF)
{
pdfComic = Poppler::Document::load(_path);
if (!pdfComic)
{
delete pdfComic;
pdfComic = 0;
QMessageBox::critical(NULL,tr("Bad PDF File"),tr("Invalid PDF file"));
emit errorOpening();
return;
}
//pdfComic->setRenderHint(Poppler::Document::Antialiasing, true);
pdfComic->setRenderHint(Poppler::Document::TextAntialiasing, true);
int nPages = pdfComic->numPages();
emit pageChanged(0); // this indicates new comic, index=0
emit numPages(nPages);
_loaded = true;
//QMessageBox::critical(NULL,QString("%1").arg(nPages),tr("Invalid PDF file"));
_pages.clear();
_pages.resize(nPages);
_loadedPages = QVector<bool>(nPages,false);
for(int i=0;i<nPages;i++)
{
Poppler::Page* pdfpage = pdfComic->page(i);
if (pdfpage)
{
QImage img = pdfpage->renderToImage(150,150); //TODO use defaults if not using X11 (e.g. MS Win)
delete pdfpage;
QByteArray ba;
QBuffer buf(&ba);
img.save(&buf, "jpg");
_pages[i] = ba;
emit imageLoaded(i);
emit imageLoaded(i,_pages[i]);
}
}
delete pdfComic;
emit imagesLoaded();
}
else
{
QDir d(_pathDir);
QStringList l;
l EXTENSIONS;
d.setNameFilters(l);
d.setFilter(QDir::Files|QDir::NoDotAndDotDot);
//d.setSorting(QDir::Name|QDir::IgnoreCase|QDir::LocaleAware);
QFileInfoList list = d.entryInfoList();
qSort(list.begin(),list.end(),naturalSortLessThanCIFileInfo);
int nPages = list.size();
_pages.clear();
_pages.resize(nPages);
_loadedPages = QVector<bool>(nPages,false);
if(nPages==0)
{
QMessageBox::critical(NULL,tr("No images found"),tr("There are not images on the selected folder"));
emit errorOpening();
}
else
{
emit pageChanged(0); // this indicates new comic, index=0
emit numPages(_pages.size());
_loaded = true;
for(int i=0;i<nPages;i++)
{
QFile f(list.at(i).absoluteFilePath());
f.open(QIODevice::ReadOnly);
_pages[i]=f.readAll();
emit imageLoaded(i);
emit imageLoaded(i,_pages[i]);
}
}
emit imagesLoaded();
}
}
//-----------------------------------------------------------------------------
void Comic::loadSizes()
{
QRegExp rx("[0-9]{4}-[0-9]{2}-[0-9]{2}[ ]+[0-9]{2}:[0-9]{2}:[0-9]{2}[ ]+.{5}[ ]+([0-9]+)[ ]+([0-9]+)[ ]+(.+)");
QByteArray ba = _7z->readAllStandardOutput();
QList<QByteArray> lines = ba.split('\n');
QByteArray line;
QString name;
foreach(line,lines)
{
if(rx.indexIn(QString(line))!=-1)
{
_sizes.push_back(rx.cap(1).toInt());
name = rx.cap(3).trimmed();
_order.push_back(name);
_fileNames.push_back(name);
}
}
if(_sizes.size()==0)
{
QMessageBox::critical(NULL,tr("File error"),tr("File not found or not images in file"));
emit errorOpening();
return;
}
_pages.resize(_sizes.size());
_loadedPages = QVector<bool>(_sizes.size(),false);
emit pageChanged(0); // this indicates new comic, index=0
emit numPages(_pages.size());
_loaded = true;
_cfi=0;
qSort(_fileNames.begin(),_fileNames.end(), naturalSortLessThanCI);
int i=0;
foreach(name,_fileNames)
{
_newOrder.insert(name,i);
i++;
}
_7ze = new QProcess();
QStringList attributes;
attributes << "e" << "-ssc-" << "-so" << "-r" << _path EXTENSIONS;
connect(_7ze,SIGNAL(error(QProcess::ProcessError)),this,SLOT(openingError(QProcess::ProcessError)));
connect(_7ze,SIGNAL(readyReadStandardOutput()),this,SLOT(loadImages(void)));
connect(_7ze,SIGNAL(finished(int,QProcess::ExitStatus)),this,SLOT(loadFinished(void)));
_7ze->start(QCoreApplication::applicationDirPath()+"/utils/7z",attributes);
}
//-----------------------------------------------------------------------------
void Comic::loadImages()
{
QByteArray ba = _7ze->readAllStandardOutput();
int s;
int rigthIndex;
while(ba.size()>0)
{
rigthIndex = _newOrder.value(_order[_cfi]);
s = _pages[rigthIndex].size();
_pages[rigthIndex].append(ba.left(_sizes[_cfi]-s));
ba.remove(0,_sizes[_cfi]-s);
if(_pages[rigthIndex].size()==static_cast<int>(_sizes[_cfi]))
{
emit imageLoaded(rigthIndex);
emit imageLoaded(rigthIndex,_pages[rigthIndex]);
_cfi++;
}
}
}
//-----------------------------------------------------------------------------
void Comic::openingError(QProcess::ProcessError error)
{
switch(error)
{
case QProcess::FailedToStart:
QMessageBox::critical(NULL,tr("7z not found"),tr("7z wasn't found in your PATH."));
break;
case QProcess::Crashed:
QMessageBox::critical(NULL,tr("7z crashed"),tr("7z crashed."));
break;
case QProcess::ReadError:
QMessageBox::critical(NULL,tr("7z reading"),tr("problem reading from 7z"));
break;
case QProcess::UnknownError:
QMessageBox::critical(NULL,tr("7z problem"),tr("Unknown error 7z"));
break;
default:
//TODO
break;
}
_loaded = false;
emit errorOpening();
}
int Comic::nextPage()
{
if(_index<_pages.size()-1)
@ -286,7 +45,7 @@ int Comic::nextPage()
return _index;
}
//-----------------------------------------------------------------------------
//---------------------------------------------------------------------------
int Comic::previousPage()
{
if(_index>0)
@ -388,86 +147,57 @@ bool Comic::pageIsLoaded(int page)
return _loadedPages[page];
}
//
//
//
//
//
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
FileComic::FileComic()
:Comic()
{
}
FileComic::FileComic(const QString & path)
:Comic(path)
{
load(path);
}
//-----------------------------------------------------------------------------
Comic2::Comic2()
:_pages(),_index(0),_path(),_loaded(false),_loadedPages()
FileComic::~FileComic()
{
setup();
//Comic::~Comic();
}
//-----------------------------------------------------------------------------
Comic2::Comic2(const QString pathFile)
:_pages(),_index(0),_path(pathFile),_loaded(false),_loadedPages()
{
setup();
loadFromFile(pathFile);
}
//-----------------------------------------------------------------------------
Comic2::~Comic2()
{
/*delete _7z;
delete _7ze;
delete bm;*/ //TODO safe delete
}
//-----------------------------------------------------------------------------
void Comic2::setup()
{
connect(this,SIGNAL(pageChanged(int)),this,SLOT(checkIsBookmark(int)));
connect(this,SIGNAL(imageLoaded(int)),this,SLOT(updateBookmarkImage(int)));
connect(this,SIGNAL(imageLoaded(int)),this,SLOT(setPageLoaded(int)));
}
//-----------------------------------------------------------------------------
bool Comic2::load(const QString & path)
bool FileComic::load(const QString & path)
{
QFileInfo fi(path);
if(fi.exists())
{
if(fi.isFile())
{
loadFromFile(path);
}
else
{
}
bm->newComic(path);
emit bookmarksLoaded(*bm);
_path = QDir::cleanPath(path);
//load files size
_7z = new QProcess();
QStringList attributes;
attributes << "l" << "-ssc-" << "-r" << _path EXTENSIONS;
connect(_7z,SIGNAL(finished(int,QProcess::ExitStatus)),this,SLOT(loadSizes(void)));
connect(_7z,SIGNAL(error(QProcess::ProcessError)),this,SLOT(openingError(QProcess::ProcessError)));
_7z->start(QCoreApplication::applicationDirPath()+"/utils/7z",attributes);
return true;
}
else
{
QMessageBox::critical(NULL,tr("Not found"),tr("Comic not found"));
emit errorOpening();
return false;
}
}
//-----------------------------------------------------------------------------
void Comic2::loadFromFile(const QString & pathFile)
{
_path = QDir::cleanPath(pathFile);
//load files size
_7z = new QProcess();
QStringList attributes;
attributes << "l" << "-ssc-" << "-r" << _path EXTENSIONS;
connect(_7z,SIGNAL(finished(int,QProcess::ExitStatus)),this,SLOT(loadSizes(void)));
connect(_7z,SIGNAL(error(QProcess::ProcessError)),this,SLOT(openingError(QProcess::ProcessError)));
_7z->start(QCoreApplication::applicationDirPath()+"/utils/7z",attributes);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void Comic2::loadSizes()
void FileComic::loadSizes()
{
QRegExp rx("[0-9]{4}-[0-9]{2}-[0-9]{2}[ ]+[0-9]{2}:[0-9]{2}:[0-9]{2}[ ]+.{5}[ ]+([0-9]+)[ ]+([0-9]+)[ ]+(.+)");
@ -487,7 +217,7 @@ void Comic2::loadSizes()
}
if(_sizes.size()==0)
{
//QMessageBox::critical(NULL,tr("File error"),tr("File not found or not images in file"));
QMessageBox::critical(NULL,tr("File error"),tr("File not found or not images in file"));
emit errorOpening();
return;
}
@ -515,7 +245,7 @@ void Comic2::loadSizes()
_7ze->start(QCoreApplication::applicationDirPath()+"/utils/7z",attributes);
}
//-----------------------------------------------------------------------------
void Comic2::loadImages()
void FileComic::loadImages()
{
QByteArray ba = _7ze->readAllStandardOutput();
@ -536,7 +266,7 @@ void Comic2::loadImages()
}
}
//-----------------------------------------------------------------------------
void Comic2::openingError(QProcess::ProcessError error)
void FileComic::openingError(QProcess::ProcessError error)
{
switch(error)
{
@ -559,98 +289,166 @@ void Comic2::openingError(QProcess::ProcessError error)
_loaded = false;
emit errorOpening();
}
int Comic2::nextPage()
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
FolderComic::FolderComic()
:Comic()
{
if(_index<_pages.size()-1)
_index++;
emit pageChanged(_index);
return _index;
}
//-----------------------------------------------------------------------------
int Comic2::previousPage()
FolderComic::FolderComic(const QString & path)
:Comic(path)
{
if(_index>0)
_index--;
emit pageChanged(_index);
return _index;
load(path);
}
//-----------------------------------------------------------------------------
void Comic2::setIndex(unsigned int index)
FolderComic::~FolderComic()
{
if(static_cast<int>(index)<_pages.size()-1)
_index = index;
}
bool FolderComic::load(const QString & path)
{
_path = path;
return true;
}
void FolderComic::process()
{
QDir d(_path);
QStringList l;
l EXTENSIONS;
d.setNameFilters(l);
d.setFilter(QDir::Files|QDir::NoDotAndDotDot);
//d.setSorting(QDir::Name|QDir::IgnoreCase|QDir::LocaleAware);
QFileInfoList list = d.entryInfoList();
qSort(list.begin(),list.end(),naturalSortLessThanCIFileInfo);
int nPages = list.size();
_pages.clear();
_pages.resize(nPages);
_loadedPages = QVector<bool>(nPages,false);
if(nPages==0)
{
//TODO emitir este mensaje en otro sitio
//QMessageBox::critical(NULL,QObject::tr("No images found"),QObject::tr("There are not images on the selected folder"));
emit errorOpening();
}
else
_index = _pages.size()-1;
{
emit pageChanged(0); // this indicates new comic, index=0
emit numPages(_pages.size());
_loaded = true;
emit pageChanged(_index);
}
//-----------------------------------------------------------------------------
QPixmap * Comic2::currentPage()
{
QPixmap * p = new QPixmap();
p->loadFromData(_pages[_index]);
return p;
}
//-----------------------------------------------------------------------------
QPixmap * Comic2::operator[](unsigned int index)
{
QPixmap * p = new QPixmap();
p->loadFromData(_pages[index]);
return p;
}
//-----------------------------------------------------------------------------
bool Comic2::loaded()
{
return _loaded;
}
//-----------------------------------------------------------------------------
void Comic2::loadFinished()
{
for(int i=0;i<nPages;i++)
{
QFile f(list.at(i).absoluteFilePath());
f.open(QIODevice::ReadOnly);
_pages[i]=f.readAll();
emit imageLoaded(i);
emit imageLoaded(i,_pages[i]);
}
}
emit imagesLoaded();
moveToThread(QApplication::instance()->thread());
}
//-----------------------------------------------------------------------------
void Comic2::setBookmark()
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
PDFComic::PDFComic()
:Comic()
{
}
//-----------------------------------------------------------------------------
void Comic2::removeBookmark()
PDFComic::PDFComic(const QString & path)
:Comic(path)
{
load(path);
}
//-----------------------------------------------------------------------------
void Comic2::saveBookmarks()
PDFComic::~PDFComic()
{
}
//-----------------------------------------------------------------------------
void Comic2::checkIsBookmark(int index)
bool PDFComic::load(const QString & path)
{
_path = path;
return true;
}
//-----------------------------------------------------------------------------
void Comic2::updateBookmarkImage(int index)
void PDFComic::process()
{
pdfComic = Poppler::Document::load(_path);
if (!pdfComic)
{
delete pdfComic;
pdfComic = 0;
//TODO emitir este mensaje en otro sitio
//QMessageBox::critical(NULL,QObject::tr("Bad PDF File"),QObject::tr("Invalid PDF file"));
emit errorOpening();
return;
}
//pdfComic->setRenderHint(Poppler::Document::Antialiasing, true);
pdfComic->setRenderHint(Poppler::Document::TextAntialiasing, true);
int nPages = pdfComic->numPages();
emit pageChanged(0); // this indicates new comic, index=0
emit numPages(nPages);
_loaded = true;
//QMessageBox::critical(NULL,QString("%1").arg(nPages),tr("Invalid PDF file"));
_pages.clear();
_pages.resize(nPages);
_loadedPages = QVector<bool>(nPages,false);
for(int i=0;i<nPages;i++)
{
Poppler::Page* pdfpage = pdfComic->page(i);
if (pdfpage)
{
QImage img = pdfpage->renderToImage(150,150); //TODO use defaults if not using X11 (e.g. MS Win)
delete pdfpage;
QByteArray ba;
QBuffer buf(&ba);
img.save(&buf, "jpg");
_pages[i] = ba;
emit imageLoaded(i);
emit imageLoaded(i,_pages[i]);
}
}
delete pdfComic;
emit imagesLoaded();
moveToThread(QApplication::instance()->thread());
}
Comic * FactoryComic::newComic(const QString & path)
{
}
//-----------------------------------------------------------------------------
void Comic2::setPageLoaded(int page)
{
_loadedPages[page] = true;
}
//-----------------------------------------------------------------------------
QByteArray Comic2::getRawPage(int page)
{
if(page < 0 || page >= _pages.size())
return QByteArray();
return _pages[page];
}
//-----------------------------------------------------------------------------
bool Comic2::pageIsLoaded(int page)
{
if(page < 0 || page >= _pages.size())
return false;
return _loadedPages[page];
QFileInfo fi(path);
if(fi.exists())
if(fi.isFile())
if(fi.suffix().compare("pdf",Qt::CaseInsensitive) == 0)
return new PDFComic();
else
return new FileComic();
else
if(fi.isDir())
return new FolderComic();
else
return NULL;
}

131
YACReader/comic.h
View File

@ -10,10 +10,10 @@
#include "poppler-qt4.h"
class Comic : public QThread
class Comic : public QObject
{
Q_OBJECT
private:
protected:
//Comic pages, one QPixmap for each file.
QVector<QByteArray> _pages;
QVector<bool> _loadedPages;
@ -24,26 +24,25 @@
int _index;
QString _path;
bool _loaded;
QProcess * _7z;
QProcess * _7ze;
int _cfi;
QString _pathDir;
Bookmarks * bm;
void run();
//pdf
Poppler::Document * pdfComic;
bool _isPDF;
public:
//Constructors
Comic();
Comic(const QString pathFile);
Comic(const QString & pathFile);
~Comic();
void setup();
//Load pages from file
bool load(const QString & path);
void loadFromFile(const QString & pathFile);
virtual bool load(const QString & path) = 0;
/*void loadFromFile(const QString & pathFile);
void loadFromDir(const QString & pathDir);
void loadFromPDF(const QString & pathPDF);
void loadFromPDF(const QString & pathPDF);*/
int nextPage();
int previousPage();
void setIndex(unsigned int index);
@ -57,9 +56,6 @@
bool pageIsLoaded(int page);
public slots:
void loadImages();
void loadSizes();
void openingError(QProcess::ProcessError error);
void loadFinished();
void setBookmark();
void removeBookmark();
@ -79,69 +75,64 @@
};
class Comic2 : public QObject
class FileComic : public Comic
{
Q_OBJECT
private:
//Comic pages, one QPixmap for each file.
QVector<QByteArray> _pages;
QVector<bool> _loadedPages;
QVector<uint> _sizes;
QStringList _fileNames;
QMap<QString,int> _newOrder;
QVector<QString> _order;
int _index;
QString _path;
bool _loaded;
QProcess * _7z;
QProcess * _7ze;
int _cfi;
QString _pathDir;
public:
//Constructors
Comic2();
Comic2(const QString pathFile);
~Comic2();
void setup();
//Load pages from file
bool load(const QString & path);
void loadFromFile(const QString & pathFile);
int nextPage();
int previousPage();
void setIndex(unsigned int index);
unsigned int getIndex(){return _index;};
unsigned int numPages(){return _pages.size();}
QPixmap * currentPage();
bool loaded();
QPixmap * operator[](unsigned int index);
QVector<QByteArray> * getRawData(){return &_pages;};
QByteArray getRawPage(int page);
bool pageIsLoaded(int page);
FileComic();
FileComic(const QString & path);
~FileComic();
public slots:
void loadImages();
void loadSizes();
void openingError(QProcess::ProcessError error);
void loadFinished();
void setBookmark();
void removeBookmark();
void saveBookmarks();
void checkIsBookmark(int index);
void updateBookmarkImage(int);
void setPageLoaded(int page);
signals:
void imagesLoaded();
void imageLoaded(int index);
void imageLoaded(int index,const QByteArray & image);
void pageChanged(int index);
void numPages(unsigned int numPages);
void errorOpening();
void isBookmark(bool);
void bookmarksLoaded(const Bookmarks &);
virtual bool load(const QString & path);
public slots:
void loadImages();
void loadSizes();
void openingError(QProcess::ProcessError error);
};
class FolderComic : public Comic
{
Q_OBJECT
private:
//void run();
public:
FolderComic();
FolderComic(const QString & path);
~FolderComic();
virtual bool load(const QString & path);
public slots:
void process();
};
class PDFComic : public Comic
{
Q_OBJECT
private:
//pdf
Poppler::Document * pdfComic;
//void run();
public:
PDFComic();
PDFComic(const QString & path);
~PDFComic();
virtual bool load(const QString & path);
public slots:
void process();
};
class FactoryComic
{
public:
static Comic * newComic(const QString & path);
};
#endif

17
YACReader/main.cpp
View File

@ -13,8 +13,21 @@
#include "configuration.h"
#if defined(WIN32) && defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#define DEBUG_NEW new( _NORMAL_BLOCK, __FILE__, __LINE__ )
#define new DEBUG_NEW
#endif
int main(int argc, char * argv[])
{
#if defined(_MSC_VER) && defined(_DEBUG)
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#endif
QApplication app(argc, argv);
QTranslator translator;
@ -29,6 +42,8 @@ int main(int argc, char * argv[])
int ret = app.exec();
Configuration::getConfiguration().save();
_CrtDumpMemoryLeaks();
return ret;
}

2
YACReader/main_window_viewer.cpp
View File

@ -630,7 +630,7 @@ void MainWindowViewer::getSiblingComics(QString path,QString currentComic)
{
QDir d(path);
d.setFilter(QDir::Files|QDir::NoDotAndDotDot);
d.setNameFilters(QStringList() << "*.cbr" << "*.cbz" << "*.rar" << "*.zip" << "*.tar");
d.setNameFilters(QStringList() << "*.cbr" << "*.cbz" << "*.rar" << "*.zip" << "*.tar" << "*.pdf");
d.setSorting(QDir::Name|QDir::IgnoreCase|QDir::LocaleAware);
QStringList list = d.entryList();
int index = list.indexOf(currentComic);

48
YACReader/render.cpp
View File

@ -378,7 +378,11 @@ void Render::setRotation(int degrees)
void Render::setComic(Comic * c)
{
if(comic !=0)
delete comic;
{
comic->moveToThread(QApplication::instance()->thread());
comic->disconnect();
comic->deleteLater();
}
comic = c;
}
@ -398,9 +402,29 @@ void Render::update()
void Render::load(const QString & path)
{
if(comic!=0)
delete comic;
comic = new Comic();
{
comic->moveToThread(QApplication::instance()->thread());
comic->disconnect();
comic->deleteLater();
}
//comic->moveToThread(QApplication::instance()->thread());
comic = FactoryComic::newComic(path);
if(comic == NULL) //archivo no encontrado o no válido
return;
previousIndex = currentIndex = 0;
QThread * thread = NULL;
if (typeid(*comic) != typeid(FileComic))
{
thread = new QThread();
comic->moveToThread(thread);
connect(thread, SIGNAL(started()), comic, SLOT(process()));
connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
}
connect(comic,SIGNAL(errorOpening()),this,SIGNAL(errorOpening()));
connect(comic,SIGNAL(errorOpening()),this,SLOT(reset()));
@ -413,12 +437,18 @@ void Render::load(const QString & path)
connect(comic,SIGNAL(isBookmark(bool)),this,SIGNAL(currentPageIsBookmark(bool)));
connect(comic,SIGNAL(bookmarksLoaded(const Bookmarks &)),this,SIGNAL(bookmarksLoaded(const Bookmarks &)));
pagesReady.clear();
if(comic->load(path)) //garantiza que se va a intentar abrir el cómic
{
invalidate();
loadedComic = true;
update();
}
comic->load(path); //garantiza que se va a intentar abrir el cómic
if(thread != NULL)
thread->start();
invalidate();
loadedComic = true;
update();
}

2
YACReaderLibrary/main.cpp
View File

@ -8,6 +8,8 @@
LibraryWindow * mw;
Startup * s;
int main( int argc, char ** argv )
{
QApplication app( argc, argv );

57
YACReaderLibrary/server/controllers/comiccontroller.cpp
View File

@ -10,31 +10,6 @@ extern LibraryWindow * mw;
#include "comic_db.h"
#include "comic.h"
Synchronizer::Synchronizer(Comic2 * c,QString p,QThread * f)
:QThread(),comic(c),path(p),from(f)
{
}
void Synchronizer::run()
{
connect(comic,SIGNAL(numPages(unsigned int)),this,SLOT(waitedSignal()));
loaded = comic->load(path);
}
void Synchronizer::waitedSignal()
{
if(loaded)
{
comic->moveToThread(from);
quit();
}
else
{
exit(-1);
}
}
ComicController::ComicController() {}
@ -64,21 +39,31 @@ void ComicController::service(HttpRequest& request, HttpResponse& response)
ComicDB comic = mw->getComicInfo(libraryName, comicId);
Comic2 * comicFile = new Comic2;
//Synchronizer * synchronizer = new Synchronizer(comicFile,libraries.value(libraryName)+comic.path, this->thread());
//comicFile->moveToThread(synchronizer);
Comic * comicFile = FactoryComic::newComic(libraries.value(libraryName)+comic.path);
//synchronizer->start();
//QApplication::instance()->exec();
//synchronizer->wait(20000);
if(comicFile->load(libraries.value(libraryName)+comic.path))
if(comicFile != NULL)
{
QThread * thread = NULL;
if (typeid(*comicFile) != typeid(FileComic))
{
thread = new QThread();
comicFile->moveToThread(thread);
connect(thread, SIGNAL(started()), comicFile, SLOT(process()));
connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
}
comicFile->load(libraries.value(libraryName)+comic.path);
if(thread != NULL)
thread->start();
session.setCurrentComic(comic.id, comicFile);
response.setHeader("Content-Type", "plain/text; charset=ISO-8859-1");
response.writeText(QString("library:%1\r\n").arg(libraryName));
response.writeText(comic.toTXT(),true);
}

19
YACReaderLibrary/server/controllers/comiccontroller.h
View File

@ -6,7 +6,7 @@
#include "httprequesthandler.h"
#include <QThread>
class Comic2;
class Comic;
class QString;
class ComicController : public HttpRequestHandler {
@ -20,21 +20,4 @@ public:
void service(HttpRequest& request, HttpResponse& response);
};
class Synchronizer : public QThread
{
Q_OBJECT
public:
Synchronizer(Comic2 * c, QString p, QThread * f);
bool loaded;
private:
Comic2 * comic;
QString path;
QThread * from;
void run();
public slots:
void waitedSignal();
};
#endif // COMICCONTROLLER_H

4
YACReaderLibrary/server/controllers/pagecontroller.cpp
View File

@ -19,8 +19,8 @@ void PageController::service(HttpRequest& request, HttpResponse& response)
qulonglong comicId = pathElements.at(4).toULongLong();
unsigned int page = pathElements.at(6).toUInt();
Comic2 * comicFile = session.getCurrentComic();
if(session.getCurrentComicId() != 0 && !QPointer<Comic2>(comicFile).isNull())
Comic * comicFile = session.getCurrentComic();
if(session.getCurrentComicId() != 0 && !QPointer<Comic>(comicFile).isNull())
{
if(comicId == session.getCurrentComicId() && page < comicFile->numPages())
{

6
YACReaderLibrary/server/lib/bfHttpServer/httpsession.cpp
View File

@ -218,7 +218,7 @@ qulonglong HttpSession::getCurrentComicId()
else
return 0;
}
Comic2* HttpSession::getCurrentComic()
Comic* HttpSession::getCurrentComic()
{
if(dataPtr)
{
@ -233,13 +233,13 @@ void HttpSession::dismissCurrentComic()
{
if(dataPtr->yacreaderSessionData.comic != 0)
{
delete dataPtr->yacreaderSessionData.comic;
dataPtr->yacreaderSessionData.comic->deleteLater();
dataPtr->yacreaderSessionData.comic = 0;
}
dataPtr->yacreaderSessionData.comicId = 0;
}
}
void HttpSession::setCurrentComic(qulonglong id, Comic2 * comic)
void HttpSession::setCurrentComic(qulonglong id, Comic * comic)
{
if(dataPtr)
{

6
YACReaderLibrary/server/lib/bfHttpServer/httpsession.h
View File

@ -104,9 +104,9 @@ public:
//current comic
qulonglong getCurrentComicId();
Comic2 * getCurrentComic();
Comic * getCurrentComic();
void dismissCurrentComic();
void setCurrentComic(qulonglong id, Comic2 * comic);
void setCurrentComic(qulonglong id, Comic * comic);
//device identification
QString getDeviceType();
@ -125,7 +125,7 @@ private:
QString device;
QString display;
qulonglong comicId;
Comic2 * comic;
Comic * comic;
};
struct HttpSessionData {

9
common/yacreader_flow_gl.cpp
View File

@ -198,7 +198,7 @@ struct Preset pressetYACReaderFlowDownConfig = {
};
/*Constructor*/
YACReaderFlowGL::YACReaderFlowGL(QWidget *parent,struct Preset p)
:QGLWidget(QGLFormat(QGL::SampleBuffers), parent),numObjects(0),lazyPopulateObjects(-1),bUseVSync(false)
:QGLWidget(QGLFormat(QGL::SampleBuffers), parent),numObjects(0),lazyPopulateObjects(-1),bUseVSync(false),hasBeenInitialized(false)
{
updateCount = 0;
config = p;
@ -278,6 +278,8 @@ void YACReaderFlowGL::initializeGL()
if(lazyPopulateObjects!=-1)
populate(lazyPopulateObjects);
hasBeenInitialized = true;
}
void YACReaderFlowGL::paintGL()
@ -690,7 +692,7 @@ void YACReaderFlowGL::populate(int n)
float x = 1;
float y = 1 * (700.f/480.0f);
int i;
for(i = 0;i<n;i++){
insert("cover", defaultTexture, x, y);
}
@ -715,6 +717,7 @@ void YACReaderFlowGL::reset()
{
currentSelected = 0;
loaded.clear();
for(int i = 0;i<numObjects;i++){
if(cfImages[i].img != defaultTexture)
deleteTexture(cfImages[i].img);
@ -723,6 +726,8 @@ void YACReaderFlowGL::reset()
delete[] cfImages;
numObjects = 0;
if(!hasBeenInitialized)
lazyPopulateObjects = -1;
}
void YACReaderFlowGL::reload()

1
common/yacreader_flow_gl.h
View File

@ -139,6 +139,7 @@ protected:
QVector<bool> marks;
QList<QString> paths;
CFImage * cfImages;
bool hasBeenInitialized;
Performance performance;
bool bUseVSync;