harbour-seaprint/src/ippprinter.cpp
2022-08-13 20:04:10 +02:00

955 lines
29 KiB
C++

#include "ippprinter.h"
#include "ippdiscovery.h"
#include "mimer.h"
#include "convertchecker.h"
#include "papersizes.h"
#include "overrider.h"
#include "settings.h"
#include <fstream>
Q_DECLARE_METATYPE(QMargins)
Q_DECLARE_METATYPE(IppMsg)
IppPrinter::IppPrinter()
{
_worker = new PrinterWorker(this);
QObject::connect(this, &IppPrinter::urlChanged, this, &IppPrinter::onUrlChanged);
qRegisterMetaType<QTemporaryFile*>("QTemporaryFile*");
connect(this, &IppPrinter::doDoGetPrinterAttributes, _worker, &PrinterWorker::getPrinterAttributes);
connect(this, &IppPrinter::doGetJobs, _worker, &PrinterWorker::getJobs);
connect(this, &IppPrinter::doCancelJob, _worker, &PrinterWorker::cancelJob);
connect(this, &IppPrinter::doIdentify, _worker, &PrinterWorker::identify);
connect(this, &IppPrinter::doPrint, _worker, &PrinterWorker::print);
connect(this, &IppPrinter::doPrint2, _worker, &PrinterWorker::print2);
connect(this, &IppPrinter::doGetStrings, _worker, &PrinterWorker::getStrings);
connect(this, &IppPrinter::doGetImage, _worker, &PrinterWorker::getImage);
connect(_worker, &PrinterWorker::progress, this, &IppPrinter::setProgress);
connect(_worker, &PrinterWorker::busyMessage, this, &IppPrinter::setBusyMessage);
connect(_worker, &PrinterWorker::failed, this, &IppPrinter::convertFailed);
qRegisterMetaType<QMargins>();
qRegisterMetaType<IppMsg>();
}
IppPrinter::~IppPrinter() {
}
QJsonObject IppPrinter::opAttrs() {
QString name = qgetenv("USER");
QJsonObject o
{
{"attributes-charset", QJsonObject {{"tag", IppMsg::Charset}, {"value", "utf-8"}}},
{"attributes-natural-language", QJsonObject {{"tag", IppMsg::NaturalLanguage}, {"value", "en-us"}}},
{"printer-uri", QJsonObject {{"tag", IppMsg::Uri}, {"value", _url.toString()}}},
{"requesting-user-name", QJsonObject {{"tag", IppMsg::NameWithoutLanguage}, {"value", name}}},
};
return o;
}
void IppPrinter::setUrl(QString url_s)
{
QUrl url = QUrl(url_s);
// If not already a good scheme, try to fixup, or give an empty url
if(url.scheme() != "ipp" && url.scheme() != "ipps" && url.scheme() != "file")
{
if(url.scheme() == "")
{
url = QUrl("ipp://"+url_s); // Why isn't setScheme working?
}
else if (url.scheme() == "http") {
url.setScheme("ipp");
}
else if (url.scheme() == "https") {
url.setScheme("ipps");
}
else {
url = QUrl();
}
}
qDebug() << url_s << url;
if(url != _url)
{
_url = url;
emit urlChanged();
}
}
void IppPrinter::onUrlChanged()
{
QMetaObject::invokeMethod(_worker, "urlChanged", Q_ARG(QUrl, httpUrl()));
refresh();
}
void IppPrinter::refresh() {
if(_url.scheme() == "file")
{
_attrs = QJsonObject();
QString localFile = _url.toLocalFile();
if(localFile.endsWith(".raw") || localFile.endsWith(".bin"))
{
try
{
std::ifstream ifs = std::ifstream(localFile.toStdString(), std::ios::in | std::ios::binary);
Bytestream InBts(ifs);
IppMsg resp(InBts);
qDebug() << resp.getStatus() << resp.getOpAttrs() << resp.getPrinterAttrs();
_attrs = resp.getPrinterAttrs();
}
catch(const std::exception& e)
{
qDebug() << e.what();
}
}
else
{
QFile file(localFile);
if(file.open(QIODevice::ReadOnly))
{
QJsonDocument JsonDocument = QJsonDocument::fromJson(file.readAll());
_attrs = JsonDocument.object();
file.close();
}
}
Overrider::instance()->apply(_attrs);
emit attrsChanged();
// For testing fake file-prinetrs with a strings file hosted elsewhere
// MaybeGetIcon();
// MaybeGetStrings();
UpdateAdditionalDocumentFormats();
}
else
{
QJsonObject o = opAttrs();
IppMsg msg = IppMsg(IppMsg::GetPrinterAttrs, o);
emit doDoGetPrinterAttributes(msg.encode());
}
}
void IppPrinter::MaybeGetStrings()
{
if(_attrs.contains("printer-strings-uri") && _strings.empty())
{
QUrl url(_attrs["printer-strings-uri"].toObject()["value"].toString());
resolveUrl(url);
if(isAllowedAddress(url))
{
emit doGetStrings(url);
}
}
}
void IppPrinter::MaybeGetIcon(bool retry)
{
if(_attrs.contains("printer-icons") && (_icon.isNull() || retry) && !_iconRetried)
{
QUrl url;
QJsonArray icons = _attrs["printer-icons"].toObject()["value"].toArray();
if(retry)
{ // If there were more than one icon, try the last one on the retry
if(icons.size() > 1)
{
url = icons.last().toString();
}
}
else
{
if(icons.size() == 3)
{ // If there are 3 icons, the first will be the 48px one, ignore it
url = icons.at(1).toString();
}
else
{
url = icons.at(0).toString();
}
}
resolveUrl(url);
if(isAllowedAddress(url))
{
emit doGetImage(url);
}
}
_iconRetried = retry;
}
void IppPrinter::UpdateAdditionalDocumentFormats()
{
_additionalDocumentFormats = QStringList();
if(_attrs.contains("printer-device-id"))
{
QJsonArray supportedMimeTypes = _attrs["document-format-supported"].toObject()["value"].toArray();
QStringList printerDeviceId = _attrs["printer-device-id"].toObject()["value"].toString().split(";");
for (QStringList::iterator it = printerDeviceId.begin(); it != printerDeviceId.end(); it++)
{
QStringList kv = it->split(":");
if(kv.length()==2 && (kv[0]=="CMD" || kv[0]=="COMMAND SET"))
{
if(!supportedMimeTypes.contains(Mimer::PDF) && kv[1].contains("PDF"))
{
_additionalDocumentFormats.append(Mimer::PDF);
}
if(!supportedMimeTypes.contains(Mimer::Postscript) &&
kv[1].contains("Postscript", Qt::CaseInsensitive))
{
_additionalDocumentFormats.append(Mimer::Postscript);
}
}
}
qDebug() << "additionalDocumentFormats" << _additionalDocumentFormats;
}
emit additionalDocumentFormatsChanged();
}
void IppPrinter::getPrinterAttributesFinished(CURLcode res, Bytestream data)
{
qDebug() << res;
_attrs = QJsonObject();
if(res == CURLE_OK)
{
try {
IppMsg resp(data);
qDebug() << resp.getStatus() << resp.getOpAttrs() << resp.getPrinterAttrs();
_attrs = resp.getPrinterAttrs();
Overrider::instance()->apply(_attrs);
}
catch(const std::exception& e)
{
qDebug() << e.what();
}
}
emit attrsChanged();
MaybeGetStrings();
MaybeGetIcon();
UpdateAdditionalDocumentFormats();
}
void IppPrinter::printRequestFinished(CURLcode res, Bytestream data)
{
_jobAttrs = QJsonObject();
bool status = false;
if(res == CURLE_OK)
{
try {
IppMsg resp(data);
qDebug() << resp.getStatus() << resp.getOpAttrs() << resp.getJobAttrs();
_jobAttrs = resp.getJobAttrs()[0].toObject();
if(resp.getOpAttrs().keys().contains("status-message"))
{ // Sometimes there are no response attributes at all,
// maybe status-message from the operation attributes is somewhat useful
_jobAttrs["status-message"] = resp.getOpAttrs()["status-message"];
}
status = resp.getStatus() <= 0xff;
}
catch(const std::exception& e)
{
qDebug() << e.what();
}
}
else {
_jobAttrs.insert("job-state-message", QJsonObject {{"tag", IppMsg::TextWithoutLanguage},
{"value", "Network error"}});
}
emit jobAttrsChanged();
emit jobFinished(status);
}
void IppPrinter::getJobsRequestFinished(CURLcode res, Bytestream data)
{
if(res == CURLE_OK)
{
try {
IppMsg resp(data);
qDebug() << resp.getStatus() << resp.getOpAttrs() << resp.getJobAttrs();
_jobs = resp.getJobAttrs();
emit jobsChanged();
}
catch(const std::exception& e)
{
qDebug() << e.what();
}
}
}
void IppPrinter::cancelJobFinished(CURLcode res, Bytestream data)
{
bool status = false;
if(res == CURLE_OK)
{
try {
IppMsg resp(data);
qDebug() << resp.getStatus() << resp.getOpAttrs() << resp.getJobAttrs();
status = resp.getStatus() <= 0xff;
}
catch(const std::exception& e)
{
qDebug() << e.what();
}
}
emit cancelStatus(status);
getJobs();
}
void IppPrinter::identifyFinished(CURLcode /*res*/, Bytestream /*data*/)
{
}
void IppPrinter::getStringsFinished(CURLcode res, Bytestream data)
{
qDebug() << res << data.size();
if(res == CURLE_OK)
{
QByteArray ba((char*)data.raw(), data.size());
// "media-type.com.epson-coated" = "Epson Photo Quality Ink Jet";
QRegularExpression re("^\\\"(.*)\\\"\\s*=\\s*\\\"(.*)\\\";");
QList<QByteArray> bl = ba.split('\n');
for(QByteArray l : bl)
{
QRegularExpressionMatch match = re.match(l);
if(match.hasMatch())
{
_strings[match.captured(1)] = match.captured(2);
}
}
}
}
void IppPrinter::getImageFinished(CURLcode res, Bytestream data)
{
qDebug() << res << data.size();
if(res == CURLE_OK)
{
QImage tmp;
if(tmp.loadFromData(data.raw(), data.size(), "PNG"))
{
_icon = tmp;
qDebug() << "image loaded" << _icon;
emit iconChanged();
if(tmp.size().width() < 128)
{
MaybeGetIcon(true);
}
}
}
}
void IppPrinter::convertFailed(QString message)
{
_jobAttrs = QJsonObject();
_jobAttrs.insert("job-state-message", QJsonObject {{"tag", IppMsg::TextWithoutLanguage}, {"value", message}});
emit jobAttrsChanged();
emit jobFinished(false);
}
QString firstMatch(QJsonArray supported, QStringList wanted)
{
for(QStringList::iterator it = wanted.begin(); it != wanted.end(); it++)
{
if(supported.contains(*it))
{
return *it;
}
}
return "";
}
QString targetFormatIfAuto(QString documentFormat, QString mimeType, QJsonArray supportedMimeTypes)
{
if(documentFormat == Mimer::OctetStream)
{
QStringList PdfPrioList = {Mimer::PDF, Mimer::Postscript, Mimer::PWG, Mimer::URF};
if(mimeType == Mimer::PDF)
{
return firstMatch(supportedMimeTypes, PdfPrioList);
}
else if(mimeType == Mimer::Postscript)
{
return firstMatch(supportedMimeTypes, {Mimer::Postscript});
}
else if(mimeType == Mimer::Plaintext)
{
return firstMatch(supportedMimeTypes, PdfPrioList << Mimer::Plaintext);
}
else if(Mimer::isOffice(mimeType))
{
return firstMatch(supportedMimeTypes, PdfPrioList);
}
else if(documentFormat == Mimer::SVG)
{
QStringList SvgPrioList {Mimer::PWG, Mimer::URF, Mimer::PDF, Mimer::Postscript};
return firstMatch(supportedMimeTypes, SvgPrioList);
}
else if(Mimer::isImage(mimeType))
{
QStringList ImageFormatPrioList {Mimer::PNG, Mimer::PWG, Mimer::URF, Mimer::PDF, Mimer::Postscript, Mimer::JPEG};
if(mimeType == Mimer::JPEG)
{
// Prioritize transferring JPEG as JPEG, as it will not be transcoded
// Normally, it is the last choice (as the others are lossless)
ImageFormatPrioList.prepend(mimeType);
}
return firstMatch(supportedMimeTypes, ImageFormatPrioList);
}
return documentFormat;
}
return documentFormat;
}
void IppPrinter::adjustRasterSettings(QString filename, QString mimeType, QJsonObject& jobAttrs, PrintParameters& Params)
{
if(Params.format != PrintParameters::PWG && Params.format != PrintParameters::URF)
{
return;
}
jobAttrs.remove("printer-resolution");
if(Params.format == PrintParameters::PWG)
{
quint32 diff = std::numeric_limits<quint32>::max();
quint32 AdjustedHwResX = Params.hwResW;
quint32 AdjustedHwResY = Params.hwResH;
for(QJsonValue res : _attrs["pwg-raster-document-resolution-supported"].toObject()["value"].toArray())
{
QJsonObject resObj = res.toObject();
if(resObj["units"] != 3)
{
continue;
}
quint32 tmpDiff = std::abs(int(Params.hwResW-resObj["x"].toInt())) + std::abs(int(Params.hwResH-resObj["y"].toInt()));
if(tmpDiff < diff)
{
diff = tmpDiff;
AdjustedHwResX = resObj["x"].toInt();
AdjustedHwResY = resObj["y"].toInt();
}
}
Params.hwResW = AdjustedHwResX;
Params.hwResH = AdjustedHwResY;
}
else if(Params.format == PrintParameters::URF)
{ // Ensure Params.format resolution for URF
Params.hwResW = Params.hwResH = std::min(Params.hwResW, Params.hwResH);
quint32 diff = std::numeric_limits<quint32>::max();
quint32 AdjustedHwRes = Params.hwResW;
QJsonArray urfSupported = _attrs["urf-supported"].toObject()["value"].toArray();
for(QJsonValue us : urfSupported)
{
if(us.toString().startsWith("RS"))
{ //RS300[-600]
QStringList resolutions = us.toString().mid(2).split("-");
for(QString res : resolutions)
{
int intRes = res.toInt();
quint32 tmpDiff = std::abs(int(Params.hwResW - intRes));
if(tmpDiff < diff)
{
diff = tmpDiff;
AdjustedHwRes = intRes;
}
}
Params.hwResW = Params.hwResH = AdjustedHwRes;
break;
}
}
}
QString Sides = getAttrOrDefault(jobAttrs, "sides").toString();
if(Sides != "" && Sides != "one-sided")
{
if(Params.format == PrintParameters::PWG)
{
QString DocumentSheetBack = _attrs["pwg-raster-document-sheet-back"].toObject()["value"].toString();
if(Sides=="two-sided-long-edge")
{
if(DocumentSheetBack=="flipped")
{
Params.backVFlip=true;
}
else if(DocumentSheetBack=="rotated")
{
Params.backHFlip=true;
Params.backVFlip=true;
}
}
else if(Sides=="two-sided-short-edge")
{
if(DocumentSheetBack=="flipped")
{
Params.backHFlip=true;
}
else if(DocumentSheetBack=="manual-tumble")
{
Params.backHFlip=true;
Params.backVFlip=true;
}
}
}
else if(Params.format == PrintParameters::URF)
{
QJsonArray URfSupported = _attrs["urf-supported"].toObject()["value"].toArray();
if(Sides=="two-sided-long-edge")
{
if(URfSupported.contains("DM2"))
{
Params.backVFlip=true;
}
else if(URfSupported.contains("DM3"))
{
Params.backHFlip=true;
Params.backVFlip=true;
}
}
else if(Sides=="two-sided-short-edge")
{
if(URfSupported.contains("DM2"))
{
Params.backHFlip=true;
}
else if(URfSupported.contains("DM4"))
{
Params.backHFlip=true;
Params.backVFlip=true;
}
}
}
}
int copies_requested = getAttrOrDefault(jobAttrs, "copies").toInt(1);
QJsonArray varying_attributes = _attrs["document-format-varying-attributes"].toObject()["value"].toArray();
bool supports_copies = _attrs.contains("copies-supported")
&& _attrs["copies-supported"].toObject()["value"].toObject()["high"].toInt(1) != 1
// assume raster formats causes the variation in supported copies
&& !(varying_attributes.contains("copies-supported") || varying_attributes.contains("copies"));
if(copies_requested > 1 && !supports_copies)
{
QString copyMode = getAttrOrDefault(jobAttrs, "multiple-document-handling").toString();
qDebug() << "Doing local copies" << copyMode << copies_requested;
if(copyMode == "separate-documents-uncollated-copies")
{ // Only do silly copies if explicitly requested
Params.pageCopies = copies_requested;
}
else
{
Params.documentCopies = copies_requested;
}
jobAttrs.remove("copies");
if(Sides != "one-sided")
{
bool singlePageRange = false;
if(Params.pageRangeList.size() == 1)
{
size_t fromPage = Params.pageRangeList.begin()->first;
size_t toPage = Params.pageRangeList.begin()->second;
singlePageRange = fromPage != 0 && fromPage == toPage;
}
bool singlePageDocument = (Mimer::instance()->isImage(mimeType) ||
(mimeType == Mimer::PDF && ConvertChecker::instance()->pdfPages(filename) == 1));
if(singlePageDocument || singlePageRange)
{
jobAttrs.insert("sides", QJsonObject {{"tag", IppMsg::Keyword}, {"value", "one-sided"}});
qDebug() << "Optimizing one-page document to one-sided";
}
}
}
}
void IppPrinter::print(QJsonObject jobAttrs, QString filename)
{
qDebug() << "printing" << filename << jobAttrs;
_progress = "";
emit progressChanged();
PrintParameters Params;
QFileInfo fileinfo(filename);
if(!fileinfo.exists())
{
emit convertFailed(tr("Failed to open file"));
return;
}
Mimer* mimer = Mimer::instance();
QString mimeType = mimer->get_type(filename);
QJsonArray supportedMimeTypes = _attrs["document-format-supported"].toObject()["value"].toArray();
for(QStringList::iterator it = _additionalDocumentFormats.begin(); it != _additionalDocumentFormats.end(); it++)
{
supportedMimeTypes.append(*it);
}
qDebug() << supportedMimeTypes << supportedMimeTypes.contains(mimeType);
if(!Params.setPaperSize(getAttrOrDefault(jobAttrs, "media").toString(Params.paperSizeName.c_str()).toStdString()))
{
emit convertFailed(tr("Unsupported paper size"));
return;
}
QString targetFormat = getAttrOrDefault(jobAttrs, "document-format").toString();
qDebug() << "target format:" << targetFormat;
QMargins margins(getAttrOrDefault(jobAttrs, "media-left-margin", "media-col").toInt(),
getAttrOrDefault(jobAttrs, "media-top-margin", "media-col").toInt(),
getAttrOrDefault(jobAttrs, "media-right-margin", "media-col").toInt(),
getAttrOrDefault(jobAttrs, "media-bottom-margin", "media-col").toInt());
// Only keep margin setting for JPEG - but only attemt to remove it if media-col exists
if(!mimer->isImage(targetFormat) && jobAttrs.contains("media-col"))
{
QJsonObject MediaCol = jobAttrs["media-col"].toObject();
QJsonObject MediaColValue = MediaCol["value"].toObject();
MediaColValue.remove("media-left-margin");
MediaColValue.remove("media-top-margin");
MediaColValue.remove("media-right-margin");
MediaColValue.remove("media-bottom-margin");
if(!MediaColValue.empty())
{
MediaCol["value"] = MediaColValue;
jobAttrs["media-col"] = MediaCol;
}
else
{
jobAttrs.remove("media-col");
}
}
if(jobAttrs.contains("media-col") && jobAttrs.contains("media"))
{
qDebug() << "moving media to media-col" << Params.paperSizeName.c_str();
int x = Params.getPaperSizeWInMillimeters()*100;
int y = Params.getPaperSizeHInMillimeters()*100;
QJsonObject Dimensions =
{{"tag", IppMsg::BeginCollection},
{"value", QJsonObject { {"x-dimension", QJsonObject{{"tag", IppMsg::Integer}, {"value", x}}},
{"y-dimension", QJsonObject{{"tag", IppMsg::Integer}, {"value", y}}} }
}};
// TODO: make a setter function
QJsonObject MediaCol = jobAttrs["media-col"].toObject();
QJsonObject MediaColValue = MediaCol["value"].toObject();
MediaColValue["media-size"] = Dimensions;
MediaCol["value"] = MediaColValue;
MediaCol["tag"] = IppMsg::BeginCollection;
jobAttrs["media-col"] = MediaCol;
jobAttrs.remove("media");
}
QJsonObject jobOpAttrs = opAttrs();
// document-format goes in the op-attrs and not the job-attrs
jobOpAttrs.insert("document-format", QJsonObject {{"tag", IppMsg::MimeMediaType}, {"value", targetFormat}});
jobAttrs.remove("document-format");
targetFormat = targetFormatIfAuto(targetFormat, mimeType, supportedMimeTypes);
qDebug() << "adjusted target format:" << targetFormat;
if(targetFormat == "" || targetFormat == Mimer::OctetStream)
{
emit convertFailed(tr("Unknown document format"));
return;
}
if(targetFormat == Mimer::PDF)
{
Params.format = PrintParameters::PDF;
}
else if(targetFormat == Mimer::Postscript)
{
Params.format = PrintParameters::Postscript;
}
else if(targetFormat == Mimer::PWG)
{
Params.format = PrintParameters::PWG;
}
else if(targetFormat == Mimer::URF)
{
Params.format = PrintParameters::URF;
}
else
{
Params.format = PrintParameters::Invalid;
}
qDebug() << "Printing job" << jobOpAttrs << jobAttrs;
QJsonValue PrinterResolutionRef = getAttrOrDefault(jobAttrs, "printer-resolution");
Params.hwResW = PrinterResolutionRef.toObject()["x"].toInt(Params.hwResW);
Params.hwResH = PrinterResolutionRef.toObject()["y"].toInt(Params.hwResH);
// Effected locally, unless it is Postscript which we cant't render
if(jobAttrs.contains("page-ranges") && mimeType != Mimer::Postscript)
{
QJsonArray tmp;
QJsonValue pageRanges = getAttrOrDefault(jobAttrs, "page-ranges");
if(pageRanges.isArray())
{
tmp = pageRanges.toArray();
}
else if(pageRanges.isObject())
{
tmp = {pageRanges.toObject()};
}
for(QJsonValueRef ref : tmp)
{
Params.pageRangeList.push_back({ref.toObject()["low"].toInt(), ref.toObject()["high"].toInt()});
}
jobAttrs.remove("page-ranges");
}
adjustRasterSettings(filename, mimeType, jobAttrs, Params);
QString Sides = getAttrOrDefault(jobAttrs, "sides").toString();
if(Sides=="two-sided-long-edge")
{
Params.duplex = true;
}
else if(Sides=="two-sided-short-edge")
{
Params.duplex = true;
Params.tumble = true;
}
Params.quality = getAttrOrDefault(jobAttrs, "print-quality").toInt();
QString PrintColorMode = getAttrOrDefault(jobAttrs, "print-color-mode").toString();
Params.colors = PrintColorMode.contains("color") ? 3 : PrintColorMode.contains("monochrome") ? 1 : Params.colors;
QJsonArray supportedOperations = _attrs["operations-supported"].toObject()["value"].toArray();
if(supportedOperations.contains(IppMsg::CreateJob) && supportedOperations.contains(IppMsg::SendDocument))
{
QJsonObject createJobOpAttrs = opAttrs();
createJobOpAttrs.insert("job-name", QJsonObject {{"tag", IppMsg::NameWithoutLanguage}, {"value", fileinfo.fileName()}});
qDebug() << "Final create op attributes:" << createJobOpAttrs;
qDebug() << "Final job attributes:" << jobAttrs;
IppMsg createJob = mk_msg(IppMsg::CreateJob, createJobOpAttrs, jobAttrs);
qDebug() << "Final job op attributes:" << jobOpAttrs;
IppMsg sendDoc = mk_msg(IppMsg::SendDocument, jobOpAttrs);
emit doPrint2(filename, mimeType, targetFormat, createJob, sendDoc, Params, margins);
}
else
{
jobOpAttrs.insert("job-name", QJsonObject {{"tag", IppMsg::NameWithoutLanguage}, {"value", fileinfo.fileName()}});
qDebug() << "Final op attributes:" << jobOpAttrs;
qDebug() << "Final job attributes:" << jobAttrs;
IppMsg job = mk_msg(IppMsg::PrintJob, jobOpAttrs, jobAttrs);
emit doPrint(filename, mimeType, targetFormat, job, Params, margins);
}
}
bool IppPrinter::getJobs() {
qDebug() << "getting jobs";
QJsonObject o = opAttrs();
o.insert("requested-attributes", QJsonObject {{"tag", IppMsg::Keyword}, {"value", "all"}});
IppMsg job = IppMsg(IppMsg::GetJobs, o, QJsonObject());
emit doGetJobs(job.encode());
return true;
}
bool IppPrinter::cancelJob(qint32 jobId) {
qDebug() << "cancelling jobs";
QJsonObject o = opAttrs();
o.insert("job-id", QJsonObject {{"tag", IppMsg::Integer}, {"value", jobId}});
IppMsg job = IppMsg(IppMsg::CancelJob, o, QJsonObject());
emit doCancelJob(job.encode());
return true;
}
bool IppPrinter::identify() {
qDebug() << "identifying";
QJsonObject o = opAttrs();
IppMsg job = IppMsg(IppMsg::IdentifyPrinter, o, QJsonObject());
emit doCancelJob(job.encode());
return true;
}
bool IppPrinter::correctSuffix()
{
for(QJsonValue u : _attrs["printer-uri-supported"].toObject()["value"].toArray())
{
QUrl url(u.toString());
if(url.path() == _url.path())
{
return true;
}
}
return false;
}
QStringList IppPrinter::suffixes()
{
QStringList res;
for(QJsonValue u : _attrs["printer-uri-supported"].toObject()["value"].toArray())
{
QUrl url(u.toString());
if(!res.contains(url.path()))
{
res.append(url.path());
}
}
res.sort();
return res;
}
QUrl IppPrinter::httpUrl() {
qDebug() << _url;
QUrl url = _url;
if(url.scheme() == "ipps")
{
url.setScheme("https");
if(url.port() == -1) {
url.setPort(443);
}
}
else
{
url.setScheme("http");
if(url.port() == -1) {
url.setPort(631);
}
}
return url;
}
void IppPrinter::setBusyMessage(QString msg)
{
_busyMessage = msg;
emit busyMessageChanged();
}
void IppPrinter::setProgress(qint64 sent, qint64 total)
{
if(total == 0)
return;
_progress = QString::number(100*sent/total);
_progress += "%";
emit progressChanged();
}
bool IppPrinter::isAllowedAddress(QUrl url)
{
bool allowed = ((url.host() == _url.host()) || Settings::instance()->allowExternalConnections());
qDebug() << url << " is allowed: " << allowed;
return allowed;
}
QJsonValue IppPrinter::getAttrOrDefault(QJsonObject jobAttrs, QString name, QString subkey)
{
if(subkey == "")
{
if(jobAttrs.contains(name))
{
return jobAttrs[name].toObject()["value"];
}
else
{
return _attrs[name+"-default"].toObject()["value"];
}
}
else
{
QJsonObject subObj = jobAttrs[subkey].toObject()["value"].toObject();
if(subObj.contains(name))
{
return subObj[name].toObject()["value"];
}
else
{
return _attrs[name+"-default"].toObject()["value"];
}
}
}
IppMsg IppPrinter::mk_msg(IppMsg::Operation operation, QJsonObject opAttrs, QJsonObject jobAttrs)
{
if(_attrs.contains("ipp-versions-supported") &&
_attrs["ipp-versions-supported"].toObject()["value"].toArray().contains("2.0"))
{
qDebug() << "TWO-POINT-ZERO";
return IppMsg(operation, opAttrs, jobAttrs, 2, 0);
}
return IppMsg(operation, opAttrs, jobAttrs);
}
void IppPrinter::resolveUrl(QUrl& url)
{
if(!IppDiscovery::instance()->resolve(url))
{ // If "proper" resolution fails, cheat...
QString host = url.host();
if(host.endsWith("."))
{
host.chop(1);
}
QString dnsSdName = _attrs["printer-dns-sd-name"].toObject()["value"].toString();
dnsSdName = dnsSdName.append(".local");
if(host.compare(dnsSdName, Qt::CaseInsensitive) == 0)
{ // This could be done unconditionally, but some might want their externally hosted stuff to work
url.setHost(_url.host());
}
}
}