void LoadFilter::detectFormat()
{
// FIXME: work-around bug 242369
if (priv->fileFormatQt.isEmpty() &&
priv->fileFormat.isEmpty() &&
priv->fileName.endsWith(".mp4")) {
if (priv->filterError == QuillImageFilter::NoError)
priv->filterError = QuillImageFilter::UnsupportedFormatError;
priv->isInvalid = true;
priv->fileFormat = "video/mp4";
return;
}
if (priv->fileFormatQt.isEmpty() &&
(priv->fileFormat.isEmpty() || priv->fileFormat.startsWith("image/"))) {
QImageReader reader;
if (!priv->iODevice)
reader.setFileName(priv->fileName);
else
reader.setDevice(priv->iODevice);
priv->fileFormatQt = formatFromReader(&reader);
}
if (priv->fileFormat.isEmpty()) {
priv->fileFormat = MimeType::fromQImageFormat(priv->fileFormatQt);
}
if (priv->fileFormatQt.isEmpty()) {
if (priv->filterError == QuillImageFilter::NoError)
priv->filterError = QuillImageFilter::UnsupportedFormatError;
priv->isInvalid = true;
}
}
void syImgReaderCodec::CloseInput() {
if(m_Reader) {
m_Reader->setDevice(0);
m_Filename.clear();
m_ImageLoaded = false;
}
}
void PictureLoader::picDownloadFinished(QNetworkReply *reply)
{
if (reply->error()) {
qDebug() << "Download failed:" << reply->errorString();
}
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (statusCode == 301 || statusCode == 302) {
QUrl redirectUrl = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
QNetworkRequest req(redirectUrl);
qDebug() << "following redirect:" << cardBeingDownloaded.getCard()->getName() << "Url:" << req.url();
networkManager->get(req);
return;
}
const QByteArray &picData = reply->peek(reply->size()); //peek is used to keep the data in the buffer for use by QImageReader
if(imageIsBlackListed(picData))
{
qDebug() << "Picture downloaded, but blacklisted, will consider it as not found";
picDownloadFailed();
reply->deleteLater();
startNextPicDownload();
return;
}
QImage testImage;
QImageReader imgReader;
imgReader.setDecideFormatFromContent(true);
imgReader.setDevice(reply);
QString extension = "." + imgReader.format(); //the format is determined prior to reading the QImageReader data into a QImage object, as that wipes the QImageReader buffer
if (extension == ".jpeg")
extension = ".jpg";
if (imgReader.read(&testImage)) {
QString setName = cardBeingDownloaded.getSetName();
if(!setName.isEmpty())
{
if (!QDir().mkpath(picsPath + "/downloadedPics/" + setName)) {
qDebug() << picsPath + "/downloadedPics/" + setName + " could not be created.";
return;
}
QFile newPic(picsPath + "/downloadedPics/" + setName + "/" + cardBeingDownloaded.getCard()->getCorrectedName() + extension);
if (!newPic.open(QIODevice::WriteOnly))
return;
newPic.write(picData);
newPic.close();
}
imageLoaded(cardBeingDownloaded.getCard(), testImage);
} else {
picDownloadFailed();
}
reply->deleteLater();
startNextPicDownload();
}
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;
}
void PictureLoader::picDownloadFinished(QNetworkReply *reply)
{
QString picsPath = _picsPath;
if (reply->error()) {
qDebug() << "Download failed:" << reply->errorString();
}
const QByteArray &picData = reply->peek(reply->size()); //peek is used to keep the data in the buffer for use by QImageReader
QImage testImage;
QImageReader imgReader;
imgReader.setDecideFormatFromContent(true);
imgReader.setDevice(reply);
QString extension = "." + imgReader.format(); //the format is determined prior to reading the QImageReader data into a QImage object, as that wipes the QImageReader buffer
if (extension == ".jpeg")
extension = ".jpg";
if (imgReader.read(&testImage)) {
QString setName = cardBeingDownloaded.getSetName();
if(!setName.isEmpty())
{
if (!QDir().mkpath(picsPath + "/downloadedPics/" + setName)) {
qDebug() << picsPath + "/downloadedPics/" + setName + " could not be created.";
return;
}
QFile newPic(picsPath + "/downloadedPics/" + setName + "/" + cardBeingDownloaded.getCard()->getCorrectedName() + extension);
if (!newPic.open(QIODevice::WriteOnly))
return;
newPic.write(picData);
newPic.close();
}
emit imageLoaded(cardBeingDownloaded.getCard(), testImage);
} else if (cardBeingDownloaded.getHq()) {
qDebug() << "HQ: received invalid picture. URL:" << reply->request().url();
cardBeingDownloaded.setHq(false);
cardsToDownload.prepend(cardBeingDownloaded);
} else {
qDebug() << "LQ: received invalid picture. URL:" << reply->request().url();
if (cardBeingDownloaded.nextSet()) {
cardBeingDownloaded.setHq(true);
mutex.lock();
loadQueue.prepend(cardBeingDownloaded);
mutex.unlock();
emit startLoadQueue();
} else
emit imageLoaded(cardBeingDownloaded.getCard(), QImage());
}
reply->deleteLater();
startNextPicDownload();
}
void MainWindow_M::openFile()
{
QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"),"./",tr("Images (*.png)"));
if(fileName.isEmpty())
return;
QFile file(fileName);
file.read(QIODevice::ReadOnly);
QImageReader imageReader;
imageReader.setDevice(&file);
renderarea->setCurrentCanvas(imageReader.read());
renderarea->setContentChanged(false);
statusBar()->showMessage(fileName.section('/', -1));
clearTempFiles();
strCurrentFileName = fileName;
}
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 );
}
QuetzalFieldsDialog::QuetzalFieldsDialog(const char *title, const char *primary,
const char *secondary, PurpleRequestFields *fields,
const char *ok_text, GCallback ok_cb,
const char *cancel_text, GCallback cancel_cb,
void *user_data, QWidget *parent)
: QuetzalRequestDialog(PURPLE_REQUEST_FIELDS, user_data, parent)
{
m_ok_cb = (PurpleRequestFieldsCb) ok_cb;
m_cancel_cb = (PurpleRequestFieldsCb) cancel_cb;
m_fields = fields;
DataItem root = createItem(title, primary, secondary);
GList *group_it = purple_request_fields_get_groups(m_fields);
bool useGroupBox = group_it->next;
debug() << "useGroupBox" << useGroupBox;
for (; group_it; group_it = group_it->next) {
PurpleRequestFieldGroup *group = reinterpret_cast<PurpleRequestFieldGroup*>(group_it->data);
DataItem groupItem;
if (useGroupBox)
groupItem = DataItem(purple_request_field_group_get_title(group));
GList *field_it = purple_request_field_group_get_fields(group);
for (; field_it; field_it = field_it->next) {
PurpleRequestField *field = reinterpret_cast<PurpleRequestField*>(field_it->data);
debug() << field->id << purple_request_field_is_visible(field)
<< purple_request_field_get_type(field);
if (!purple_request_field_is_visible(field))
continue;
DataItem item(purple_request_field_get_id(field),
purple_request_field_get_label(field),
QVariant());
switch (purple_request_field_get_type(field)) {
case PURPLE_REQUEST_FIELD_STRING:
item.setData(QString::fromUtf8(purple_request_field_string_get_default_value(field)));
item.setProperty("multiline", purple_request_field_string_is_multiline(field));
item.setProperty("password", bool(purple_request_field_string_is_masked(field)));
item.setReadOnly(!purple_request_field_string_is_editable(field));
debug() << item.name() << item.data() << item.property("password") << item.isReadOnly();
break;
case PURPLE_REQUEST_FIELD_INTEGER:
item.setData(purple_request_field_int_get_default_value(field));
item.setProperty("minValue", G_MININT);
item.setProperty("maxValue", G_MAXINT);
break;
case PURPLE_REQUEST_FIELD_BOOLEAN:
item.setData(bool(purple_request_field_bool_get_default_value(field)));
break;
case PURPLE_REQUEST_FIELD_CHOICE:
{
GList *labels = purple_request_field_choice_get_labels(field);
QStringList alternatives;
for (; labels; labels = labels->next)
alternatives << QString::fromUtf8(reinterpret_cast<char*>(labels->data));
item.setData(alternatives.value(purple_request_field_choice_get_default_value(field)));
item.setProperty("alternatives", alternatives);
}
break;
case PURPLE_REQUEST_FIELD_LIST:
break;
case PURPLE_REQUEST_FIELD_LABEL:
item.setData(purple_request_field_get_label(field));
item.setReadOnly(true);
item.setProperty("hideTitle", true);
break;
case PURPLE_REQUEST_FIELD_IMAGE:
{
QImageReader reader;
QByteArray data = QByteArray::fromRawData(purple_request_field_image_get_buffer(field),
purple_request_field_image_get_size(field));
QBuffer buffer(&data);
reader.setDevice(&buffer);
QSize imageSize = reader.size();
if (imageSize.isValid()) {
imageSize.setWidth(imageSize.width() * purple_request_field_image_get_scale_x(field));
imageSize.setHeight(imageSize.height() * purple_request_field_image_get_scale_y(field));
reader.setScaledSize(imageSize);
}
item.setData(qVariantFromValue(reader.read()));
item.setProperty("imageSize", qVariantFromValue(imageSize));
item.setReadOnly(true);
}
break;
case PURPLE_REQUEST_FIELD_ACCOUNT:
break;
case PURPLE_REQUEST_FIELD_NONE:
default:
continue;
}
item.setProperty("mandatory", purple_request_field_is_required(field));
if (useGroupBox)
groupItem.addSubitem(item);
else
root.addSubitem(item);
}
if (useGroupBox)
root.addSubitem(groupItem);
}
createItem(root, ok_text, cancel_text);
return;
}
