void imgwidgetThumbThread::setimg(int i){
float multiple = 0;//倍数
QImage img;
Image imgFlag72;
imgFlag72.load("../bkbig.png");
double tim = static_cast<double>(getTickCount());
QImageReader * imgread = new QImageReader(allImgs.at(i).absoluteFilePath());
tim = ((double)getTickCount()- tim)/getTickFrequency();
//qDebug()<<"tim----------------"<<tim;
if(!imgread->canRead()){
imgread->setFileName("../picture_error.png");
}
QSize size = imgread->size();
multiple = (imgread->size().width()/72.0>imgread->size().height()/48.0
?imgread->size().width()/72.0:imgread->size().height()/48.0);
if(multiple>0)
imgread->setScaledSize(imgread->size()/multiple);
int x = (72-imgread->scaledSize().width())/2.0;
int y = (48-imgread->scaledSize().height())/2.0;
if(imgread->read(&img))
{
imgFlag72.painter(img,x,y,72,48);
double tim = static_cast<double>(getTickCount());
//imgFlag36 = imgFlag72.copy(18,0,36,48);
// tim = ((double)getTickCount()- tim)/getTickFrequency();
// qDebug()<<"tim----------------"<<tim<<i<<selectedNum;
emit sendThumb(imgFlag72,img,size,i);
}
}
bool syImgReaderCodec::OpenInput(const syString filename) {
bool result = false;
syString newfilename = filename;
if(m_Filename != "" && filename.empty()) {
newfilename = m_Filename;
} else {
newfilename = filename;
}
if(m_Reader && syString(m_Reader->fileName()) != newfilename) {
CloseInput();
if(m_Reader) {
m_Reader->setFileName(newfilename);
m_Filename = filename;
}
}
if(!m_Reader) {
m_Reader = new QImageReader(newfilename);
m_Filename = newfilename;
}
result = m_Reader->canRead();
if(result) {
if(m_Image) {
delete m_Image;
}
m_Image = new QImage(GetWidth(),GetHeight(),QImage::Format_RGB32);
}
return result;
}
bool ImageStripScene::setCurrentDirectory(const QString& path)
{
QMutexLocker locker(&m_mutex);
QDir directory(path);
QImageReader reader;
if(directory.exists()) {
clear();
if(m_loader) {
m_loader->disconnect(this);
m_loader->stopExecution();
if(!m_loader->wait(500)) {
m_loader->terminate();
m_loader->wait();
}
}
delete m_loader;
m_numItems = 0;
m_loader = new ImageLoader(m_imgSize);
connect(m_loader, SIGNAL(sigItemContentChanged(ImageItem*)), SLOT(slotItemContentChanged(ImageItem*)));
QStringList files = directory.entryList(QDir::Files);
QGraphicsLinearLayout* layout = new QGraphicsLinearLayout();
for(QStringList::iterator name=files.begin(); name!=files.end(); ++name) {
QString path = directory.absoluteFilePath(*name);
reader.setFileName(path);
if(reader.canRead()) {
ImageItem* item = new ImageItem(m_imgSize, path, m_loader);
m_loader->addPath(item, path);
layout->addItem(item);
++m_numItems;
}
}
QGraphicsWidget* widget = new QGraphicsWidget();
widget->setLayout(layout);
widget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
addItem(widget);
setSceneRect(widget->boundingRect());
m_loader->start(QThread::LowPriority);
return true;
}
return false;
}
gboolean
media_art_file_to_jpeg (const gchar *filename,
const gchar *target,
GError **error)
{
if (max_width_in_bytes < 0) {
g_debug ("Not saving album art from file, disabled in config");
return TRUE;
}
/* TODO: Add resizing support */
/* TODO: Add error reporting */
QFile file (filename);
if (!file.open (QIODevice::ReadOnly)) {
g_message ("Could not get QFile from file: '%s'", filename);
return FALSE;
}
QByteArray array = file.readAll ();
QBuffer buffer (&array);
buffer.open (QIODevice::ReadOnly);
QImageReader reader (&buffer);
if (!reader.canRead ()) {
g_message ("Could not get QImageReader from file: '%s', reader.canRead was FALSE",
filename);
return FALSE;
}
QImage image1;
image1 = reader.read ();
if (image1.hasAlphaChannel ()) {
QImage image2 (image1.size(), QImage::Format_RGB32);
image2.fill (QColor(Qt::black).rgb());
QPainter painter (&image2);
painter.drawImage (0, 0, image1);
image2.save (QString (target), "jpeg");
} else {
image1.save (QString (target), "jpeg");
}
return TRUE;
}
bool syImgReaderCodec::OpenMemoryInput(const unsigned char* buf, unsigned int size, const char* mimetype) {
bool result = false;
syString fileformat;
syString smimetype(mimetype, true);
if(smimetype == "image/gif") {
fileformat = "gif";
}
if(smimetype == "image/png") {
fileformat = "png";
} else if(smimetype == "image/jpeg") {
fileformat = "jpg";
} else if(smimetype == "image/bmp") {
fileformat = "bmp";
} else {
return false; // Unrecognized file format!
}
if(!m_Buffer) {
m_Buffer = new QBuffer;
}
m_Buffer->setData((const char*)buf,size);
if(!m_Reader) {
m_Reader = new QImageReader();
}
m_Reader->setDevice(m_Buffer);
result = m_Reader->canRead();
if(result) {
syString actual_format(QString(m_Reader->format()));
if(actual_format != fileformat) {
result = false;
}
if(m_Image) {
delete m_Image;
}
m_Image = new QImage(GetWidth(),GetHeight(),QImage::Format_RGB32);
}
if(!result) {
m_Reader->setDevice(0);
delete m_Reader;
m_Reader = 0;
delete m_Buffer;
m_Buffer = 0;
m_Filename.clear();
}
return result;
}
QPixmap Utils::renderSVG(const QString &path, const QSize &size)
{
QImageReader reader;
QPixmap pixmap;
reader.setFileName(path);
if (reader.canRead()) {
const qreal ratio = qApp->devicePixelRatio();
reader.setScaledSize(size * ratio);
pixmap = QPixmap::fromImage(reader.read());
pixmap.setDevicePixelRatio(ratio);
} else {
pixmap.load(path);
}
return pixmap;
}
void Document::pages( QVector<Okular::Page*> * pagesVector )
{
qSort( mEntries.begin(), mEntries.end(), caseSensitiveNaturalOrderLessThen );
QScopedPointer< QIODevice > dev;
int count = 0;
pagesVector->clear();
pagesVector->resize( mEntries.size() );
QImageReader reader;
foreach(const QString &file, mEntries) {
if ( mArchive ) {
const KArchiveFile *entry = static_cast<const KArchiveFile*>( mArchiveDir->entry( file ) );
if ( entry ) {
dev.reset( entry->createDevice() );
}
} else if ( mDirectory ) {
dev.reset( mDirectory->createDevice( file ) );
} else {
dev.reset( mUnrar->createDevice( file ) );
}
if ( ! dev.isNull() ) {
reader.setDevice( dev.data() );
if ( reader.canRead() )
{
QSize pageSize = reader.size();
if ( !pageSize.isValid() ) {
const QImage i = reader.read();
if ( !i.isNull() )
pageSize = i.size();
}
if ( pageSize.isValid() ) {
pagesVector->replace( count, new Okular::Page( count, pageSize.width(), pageSize.height(), Okular::Rotation0 ) );
mPageMap.append(file);
count++;
} else {
qCDebug(OkularComicbookDebug) << "Ignoring" << file << "doesn't seem to be an image even if QImageReader::canRead returned true";
}
}
}
}
pagesVector->resize( count );
}
/*
* DirFilesFilter
* QFileSystemModel의 버그(캐시?) 인지 setNameFilter를 해도 계속해서 디렉토리나 파일이 보임
* 그래서 디렉토리를 조회하여 직접 리스트를 만듬
*/
void MainWindow::DirFilesFilter(QString path) {
qDebug() << "directoryLoaded";
QModelIndex fileIdx = files_->index(path);
int numRows = files_->rowCount(fileIdx);
QImageReader imgReader;
for (int index=0; index<numRows; index++) {
QModelIndex mi = files_->index(index, 0, fileIdx);
QFileInfo fileInfo = files_->fileInfo(mi);
imgReader.setFileName(fileInfo.absoluteFilePath());
if(imgReader.canRead())
extfilter_imgs_ << fileInfo;
}
//extfilter_imgs 파일들을 모델로 만든다.
FilesModelUpdate();
}
QPixmap loadPixmap(const QString &path)
{
qreal ratio = 1.0;
QPixmap pixmap;
const qreal devicePixelRatio = qApp->devicePixelRatio();
if (!qFuzzyCompare(ratio, devicePixelRatio)) {
QImageReader reader;
reader.setFileName(qt_findAtNxFile(path, devicePixelRatio, &ratio));
if (reader.canRead()) {
reader.setScaledSize(reader.size() * (devicePixelRatio / ratio));
pixmap = QPixmap::fromImage(reader.read());
pixmap.setDevicePixelRatio(devicePixelRatio);
}
} else {
pixmap.load(path);
}
return pixmap;
}
//
// load image and store into opengl texture
// memorize image size
//
bool frag_pane::loadImage( const QString strFile )
{
bool bRetCode = false;
QImage img;
QRgb value;
QImageReader reader;
int k, iRow, i, j;
int nWidth, nHeight;
#ifdef _DEBUG
QImage img2;
#endif // _DEBUG
GLubyte *image = NULL;
// *** Load Image ***
// load image using QImageReader
// set image pixels to one-dimensional 8-bit RGBA buffer
reader.setFileName( strFile );
if( !reader.canRead( ) ) {
qDebug() << "ERROR! Failed to load image " << strFile;
goto PIX_EXIT;
}
if( !reader.read( &img ) ) {
qDebug() << "ERROR! Failed to read image " << strFile;
goto PIX_EXIT;
}
nWidth = img.width( );
nHeight = img.height( );
image = new GLubyte[nHeight*nWidth*4];
if( !image ) {
qDebug() << "ERROR! Memory Allocation Failed.";
goto PIX_EXIT;
}
// to display the texture directory onto pane, set the buffer upside down
// to copy on FBO, use the image orientation as it is
for( i = 0; i < nHeight; i++ ) {
iRow = nHeight - i - 1;
//iRow = i;
for( j = 0 ; j < nWidth ; j++ ) {
k = i * nWidth + j;
value = img.pixel( j, iRow );
image[k*4] = qRed( value );
image[k*4+1] = qGreen( value );
image[k*4+2] = qBlue( value );
image[k*4+3] = 255;
}
}
// create(or re-create) the FBO to set the loaded image
if( _in_fbo ) {
delete _in_fbo;
_in_fbo = NULL;
}
makeCurrent( );
_in_fbo = new QGLFramebufferObject( nWidth, nHeight, GL_TEXTURE_2D );
if( !_in_fbo ) {
goto PIX_EXIT;
}
// set the buffer into texture
glEnable( GL_TEXTURE_2D );
_in_fbo->bind( );
glEnable( GL_TEXTURE_2D );
glViewport( 0, 0, nWidth, nHeight );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho( 0.0, nWidth, 0.0, nHeight, -1.0, 1.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
glBindTexture( GL_TEXTURE_2D, _in_fbo->texture( ) );
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D( GL_TEXTURE_2D,
0,
GL_RGBA,
nWidth,
nHeight,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
image );
_in_fbo->release();
// --- DONE ---
bRetCode = true;
PIX_EXIT:
if( image ) {
delete[] image;
image = NULL;
}
return bRetCode;
}
