gta5view/SnapmaticPicture.cpp

834 lines
24 KiB
C++
Raw Normal View History

2017-10-09 08:35:48 +02:00
/*****************************************************************************
* gta5spv Grand Theft Auto Snapmatic Picture Viewer
2021-02-15 23:12:44 +01:00
* Copyright (C) 2016-2021 Syping
2017-10-09 08:35:48 +02:00
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*****************************************************************************/
#include "SnapmaticPicture.h"
#include <QStringBuilder>
#include <QJsonDocument>
#include <QJsonObject>
#include <QStringList>
#include <QVariantMap>
#include <QJsonArray>
#include <QFileInfo>
#include <QPainter>
#include <QString>
#include <QBuffer>
#include <QDebug>
#include <QImage>
#include <QSize>
#include <QFile>
2020-09-28 05:33:04 +02:00
#if QT_VERSION < 0x060000
#include <QTextCodec>
#endif
2017-10-12 22:21:45 +02:00
#if QT_VERSION >= 0x050000
#include <QSaveFile>
#else
#include "StandardPaths.h"
#endif
2017-10-09 08:35:48 +02:00
// IMAGES VALUES
#define snapmaticResolutionW 960
#define snapmaticResolutionH 536
#define snapmaticResolution QSize(snapmaticResolutionW, snapmaticResolutionH)
SnapmaticPicture::SnapmaticPicture(const QString &fileName, QObject *parent) : QObject(parent), picFilePath(fileName)
{
reset();
}
SnapmaticPicture::~SnapmaticPicture()
{
}
void SnapmaticPicture::reset()
{
// INIT PIC
2020-11-15 12:29:33 +01:00
p_ragePhoto.clear();
2017-10-09 08:35:48 +02:00
cachePicture = QImage();
picExportFileName = QString();
pictureStr = QString();
lastStep = QString();
sortStr = QString();
// INIT PIC BOOLS
isFormatSwitch = false;
2017-10-09 08:35:48 +02:00
picOk = false;
// INIT JSON
jsonOk = false;
// SNAPMATIC PROPERTIES
2017-12-12 04:45:46 +01:00
localProperties = {};
2017-10-09 08:35:48 +02:00
}
bool SnapmaticPicture::preloadFile()
{
QFile *picFile = new QFile(picFilePath);
picFileName = QFileInfo(picFilePath).fileName();
isFormatSwitch = false;
2021-02-15 23:12:44 +01:00
if (!picFile->open(QFile::ReadOnly)) {
lastStep = "1;/1,OpenFile," % convertDrawStringForLog(picFilePath);
2017-10-09 08:35:48 +02:00
delete picFile;
return false;
}
2020-11-15 12:29:33 +01:00
p_ragePhoto.setIODevice(picFile);
bool ok = p_ragePhoto.load();
2020-11-09 01:23:01 +01:00
picFile->close();
delete picFile;
if (!ok)
return false;
2021-02-15 23:12:44 +01:00
if (picFilePath.right(4) != QLatin1String(".g5e")) {
2020-11-15 12:29:33 +01:00
if (p_ragePhoto.photoFormat() == RagePhoto::PhotoFormat::G5EX)
isFormatSwitch = true;
2017-10-09 08:35:48 +02:00
}
emit preloaded();
return ok;
2017-10-09 08:35:48 +02:00
}
bool SnapmaticPicture::readingPicture(bool cacheEnabled_)
2017-10-09 08:35:48 +02:00
{
// Start opening file
// lastStep is like currentStep
// Set boolean values
cacheEnabled = cacheEnabled_;
bool ok = true;
2020-11-15 12:29:33 +01:00
if (!p_ragePhoto.isLoaded())
ok = preloadFile();
2017-10-09 08:35:48 +02:00
if (!ok)
2017-10-09 08:35:48 +02:00
return false;
2021-02-15 23:12:44 +01:00
if (cacheEnabled)
picOk = cachePicture.loadFromData(p_ragePhoto.photoData(), "JPEG");
if (!cacheEnabled) {
2017-10-09 08:35:48 +02:00
QImage tempPicture;
2020-11-15 12:29:33 +01:00
picOk = tempPicture.loadFromData(p_ragePhoto.photoData(), "JPEG");
2017-10-09 08:35:48 +02:00
}
parseJsonContent(); // JSON parsing is own function
updateStrings();
emit loaded();
return picOk;
}
void SnapmaticPicture::updateStrings()
{
2020-11-15 12:29:33 +01:00
QString cmpPicTitl = p_ragePhoto.title();
2017-10-09 08:35:48 +02:00
cmpPicTitl.replace('\"', "''");
cmpPicTitl.replace(' ', '_');
cmpPicTitl.replace(':', '-');
cmpPicTitl.remove('\\');
cmpPicTitl.remove('{');
cmpPicTitl.remove('}');
cmpPicTitl.remove('/');
cmpPicTitl.remove('<');
cmpPicTitl.remove('>');
cmpPicTitl.remove('*');
cmpPicTitl.remove('?');
cmpPicTitl.remove('.');
2017-12-12 04:45:46 +01:00
pictureStr = tr("PHOTO - %1").arg(localProperties.createdDateTime.toString("MM/dd/yy HH:mm:ss"));
sortStr = localProperties.createdDateTime.toString("yyMMddHHmmss") % QString::number(localProperties.uid);
QString exportStr = localProperties.createdDateTime.toString("yyyyMMdd") % "-" % QString::number(localProperties.uid);
2021-02-15 23:12:44 +01:00
if (getSnapmaticFormat() == SnapmaticFormat::G5E_Format)
picFileName = "PGTA5" % QString::number(localProperties.uid);
2017-10-09 08:35:48 +02:00
picExportFileName = exportStr % "_" % cmpPicTitl;
}
bool SnapmaticPicture::readingPictureFromFile(const QString &fileName, bool cacheEnabled_)
2017-10-09 08:35:48 +02:00
{
2021-02-15 23:12:44 +01:00
if (!fileName.isEmpty()) {
2017-10-09 08:35:48 +02:00
picFilePath = fileName;
return readingPicture(cacheEnabled_);
2017-10-09 08:35:48 +02:00
}
2021-02-15 23:12:44 +01:00
else {
2017-10-09 08:35:48 +02:00
return false;
}
}
2020-11-15 13:15:16 +01:00
bool SnapmaticPicture::setImage(const QImage &picture, bool eXtendMode)
2017-10-09 08:35:48 +02:00
{
#ifdef GTA5SYNC_DYNAMIC_PHOTOBUFFER
2020-11-15 12:29:33 +01:00
quint32 jpegPicStreamLength = p_ragePhoto.photoBuffer();
#else
quint32 jpegPicStreamLength = 524288U;
#endif
QByteArray picByteArray;
int comLvl = 100;
bool saveSuccess = false;
while (comLvl != 0 && !saveSuccess) {
QByteArray picByteArrayT;
QBuffer picStreamT(&picByteArrayT);
picStreamT.open(QIODevice::WriteOnly);
saveSuccess = picture.save(&picStreamT, "JPEG", comLvl);
picStreamT.close();
if (saveSuccess) {
2020-11-15 13:15:16 +01:00
quint32 size = picByteArrayT.length();
if (size > jpegPicStreamLength) {
if (!eXtendMode) {
comLvl--;
saveSuccess = false;
}
else {
p_ragePhoto.setPhotoBuffer(size, true);
2020-11-15 13:55:06 +01:00
picByteArray = picByteArrayT;
2020-11-15 13:15:16 +01:00
}
}
else {
#ifndef GTA5SYNC_DYNAMIC_PHOTOBUFFER
if (p_ragePhoto.photoBuffer() != jpegPicStreamLength)
p_ragePhoto.setPhotoBuffer(jpegPicStreamLength, true);
#endif
picByteArray = picByteArrayT;
2017-10-09 08:35:48 +02:00
}
}
}
if (saveSuccess)
return setPictureStream(picByteArray);
2017-10-09 08:35:48 +02:00
return false;
}
2017-12-12 04:45:46 +01:00
bool SnapmaticPicture::setPictureStream(const QByteArray &streamArray) // clean method
2017-10-09 08:35:48 +02:00
{
2020-11-15 12:29:33 +01:00
bool success = p_ragePhoto.setPhotoData(streamArray);
if (success) {
if (cacheEnabled) {
QImage replacedPicture;
replacedPicture.loadFromData(streamArray);
cachePicture = replacedPicture;
}
return true;
}
else {
return false;
}
2017-10-09 08:35:48 +02:00
}
bool SnapmaticPicture::setPictureTitl(const QString &newTitle_)
{
QString newTitle = newTitle_;
if (newTitle.length() > 39) {
newTitle = newTitle.left(39);
}
2020-11-15 12:29:33 +01:00
p_ragePhoto.setTitle(newTitle);
return true;
2017-10-09 08:35:48 +02:00
}
int SnapmaticPicture::getContentMaxLength()
{
2020-11-15 12:29:33 +01:00
return p_ragePhoto.photoBuffer();
}
2017-10-09 08:35:48 +02:00
QString SnapmaticPicture::getExportPictureFileName()
{
return picExportFileName;
}
2017-10-12 22:21:45 +02:00
QString SnapmaticPicture::getOriginalPictureFileName()
{
QString newPicFileName = picFileName;
2021-02-15 23:12:44 +01:00
if (picFileName.right(4) == ".bak") {
2017-10-12 22:21:45 +02:00
newPicFileName = QString(picFileName).remove(picFileName.length() - 4, 4);
}
2021-02-15 23:12:44 +01:00
if (picFileName.right(7) == ".hidden") {
2017-10-12 22:21:45 +02:00
newPicFileName = QString(picFileName).remove(picFileName.length() - 7, 7);
}
return newPicFileName;
}
QString SnapmaticPicture::getOriginalPictureFilePath()
{
QString newPicFilePath = picFilePath;
2021-02-15 23:12:44 +01:00
if (picFilePath.right(4) == ".bak") {
2017-10-12 22:21:45 +02:00
newPicFilePath = QString(picFilePath).remove(picFilePath.length() - 4, 4);
}
2021-02-15 23:12:44 +01:00
if (picFilePath.right(7) == ".hidden") {
2017-10-12 22:21:45 +02:00
newPicFilePath = QString(picFilePath).remove(picFilePath.length() - 7, 7);
}
return newPicFilePath;
}
2017-10-09 08:35:48 +02:00
QString SnapmaticPicture::getPictureFileName()
{
return picFileName;
}
QString SnapmaticPicture::getPictureFilePath()
{
return picFilePath;
}
QString SnapmaticPicture::getPictureSortStr()
{
return sortStr;
}
QString SnapmaticPicture::getPictureTitl()
{
2020-11-15 12:29:33 +01:00
return p_ragePhoto.title();
2017-10-09 08:35:48 +02:00
}
QString SnapmaticPicture::getPictureStr()
{
return pictureStr;
}
2017-12-12 04:45:46 +01:00
QString SnapmaticPicture::getLastStep(bool readable)
2017-10-09 08:35:48 +02:00
{
2021-02-15 23:12:44 +01:00
if (readable) {
2017-12-12 04:45:46 +01:00
QStringList lastStepList = lastStep.split(";/");
2021-02-15 23:12:44 +01:00
if (lastStepList.length() < 2)
return lastStep;
2017-12-12 04:45:46 +01:00
bool intOk;
QStringList descStepList = lastStepList.at(1).split(",");
2021-02-15 23:12:44 +01:00
if (descStepList.length() < 1)
return lastStep;
2017-12-12 04:45:46 +01:00
int argsCount = descStepList.at(0).toInt(&intOk);
if (!intOk) { return lastStep; }
2021-02-15 23:12:44 +01:00
if (argsCount == 1) {
2017-12-12 04:45:46 +01:00
QString currentAction = descStepList.at(1);
QString actionFile = descStepList.at(2);
2021-02-15 23:12:44 +01:00
if (currentAction == "OpenFile") {
2017-12-12 04:45:46 +01:00
return tr("open file %1").arg(actionFile);
}
}
2021-02-15 23:12:44 +01:00
else if (argsCount == 3 || argsCount == 4) {
2017-12-12 04:45:46 +01:00
QString currentAction = descStepList.at(1);
QString actionFile = descStepList.at(2);
QString actionError = descStepList.at(4);
QString actionError2;
if (argsCount == 4) { actionError2 = descStepList.at(5); }
2021-02-15 23:12:44 +01:00
if (currentAction == "ReadingFile") {
2017-12-12 04:45:46 +01:00
QString readableError = actionError;
2021-02-15 23:12:44 +01:00
if (actionError == "NOHEADER") {
2017-12-12 04:45:46 +01:00
readableError = tr("header not exists");
}
2021-02-15 23:12:44 +01:00
else if (actionError == "MALFORMEDHEADER") {
2017-12-12 04:45:46 +01:00
readableError = tr("header is malformed");
}
2021-02-15 23:12:44 +01:00
else if (actionError == "NOJPEG" || actionError == "NOPIC") {
2017-12-12 04:45:46 +01:00
readableError = tr("picture not exists (%1)").arg(actionError);
}
2021-02-15 23:12:44 +01:00
else if (actionError == "NOJSON" || actionError == "CTJSON") {
2017-12-12 04:45:46 +01:00
readableError = tr("JSON not exists (%1)").arg(actionError);
}
2021-02-15 23:12:44 +01:00
else if (actionError == "NOTITL" || actionError == "CTTITL") {
2017-12-12 04:45:46 +01:00
readableError = tr("title not exists (%1)").arg(actionError);
}
2021-02-15 23:12:44 +01:00
else if (actionError == "NODESC" || actionError == "CTDESC") {
2017-12-12 04:45:46 +01:00
readableError = tr("description not exists (%1)").arg(actionError);
}
2021-02-15 23:12:44 +01:00
else if (actionError == "JSONINCOMPLETE" && actionError2 == "JSONERROR") {
2017-12-12 04:45:46 +01:00
readableError = tr("JSON is incomplete and malformed");
}
2021-02-15 23:12:44 +01:00
else if (actionError == "JSONINCOMPLETE") {
2017-12-12 04:45:46 +01:00
readableError = tr("JSON is incomplete");
}
2021-02-15 23:12:44 +01:00
else if (actionError == "JSONERROR") {
2017-12-12 04:45:46 +01:00
readableError = tr("JSON is malformed");
}
return tr("reading file %1 because of %2", "Example for %2: JSON is malformed error").arg(actionFile, readableError);
}
2021-02-15 23:12:44 +01:00
else {
2017-12-12 04:45:46 +01:00
return lastStep;
}
}
2021-02-15 23:12:44 +01:00
else {
2017-12-12 04:45:46 +01:00
return lastStep;
}
}
2017-10-09 08:35:48 +02:00
return lastStep;
2017-12-12 04:45:46 +01:00
2017-10-09 08:35:48 +02:00
}
QImage SnapmaticPicture::getImage()
2017-10-09 08:35:48 +02:00
{
if (cacheEnabled) {
2017-10-09 08:35:48 +02:00
return cachePicture;
}
else {
2020-11-15 12:29:33 +01:00
return QImage::fromData(p_ragePhoto.photoData(), "JPEG");
2017-10-09 08:35:48 +02:00
}
return QImage();
}
QByteArray SnapmaticPicture::getPictureStream()
2017-10-09 08:35:48 +02:00
{
2020-11-15 12:29:33 +01:00
return p_ragePhoto.photoData();
2017-10-09 08:35:48 +02:00
}
bool SnapmaticPicture::isPicOk()
{
return picOk;
}
void SnapmaticPicture::clearCache()
{
cacheEnabled = false;
cachePicture = QImage();
}
void SnapmaticPicture::emitUpdate()
{
emit updated();
}
2017-12-17 13:03:43 +01:00
void SnapmaticPicture::emitCustomSignal(const QString &signal)
{
emit customSignal(signal);
}
2017-10-09 08:35:48 +02:00
// JSON part
bool SnapmaticPicture::isJsonOk()
{
return jsonOk;
}
QString SnapmaticPicture::getJsonStr()
{
2020-11-15 12:29:33 +01:00
return QString::fromUtf8(p_ragePhoto.jsonData());
2017-10-09 08:35:48 +02:00
}
SnapmaticProperties SnapmaticPicture::getSnapmaticProperties()
{
2017-12-12 04:45:46 +01:00
return localProperties;
2017-10-09 08:35:48 +02:00
}
void SnapmaticPicture::parseJsonContent()
{
2020-11-15 12:29:33 +01:00
QJsonObject jsonObject = p_ragePhoto.jsonObject();
QVariantMap jsonMap = jsonObject.toVariantMap();
2017-10-09 08:35:48 +02:00
bool jsonIncomplete = false;
bool jsonError = false;
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("loc")) {
if (jsonObject["loc"].isObject()) {
QJsonObject locObject = jsonObject["loc"].toObject();
2021-02-15 23:12:44 +01:00
if (locObject.contains("x")) {
2017-12-12 04:45:46 +01:00
if (locObject["x"].isDouble()) { localProperties.location.x = locObject["x"].toDouble(); }
else { jsonError = true; }
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (locObject.contains("y")) {
2017-12-12 04:45:46 +01:00
if (locObject["y"].isDouble()) { localProperties.location.y = locObject["y"].toDouble(); }
else { jsonError = true; }
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (locObject.contains("z")) {
2017-12-12 04:45:46 +01:00
if (locObject["z"].isDouble()) { localProperties.location.z = locObject["z"].toDouble(); }
else { jsonError = true; }
}
else { jsonIncomplete = true; }
}
else { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("uid")) {
bool uidOk;
2017-12-12 04:45:46 +01:00
localProperties.uid = jsonMap["uid"].toInt(&uidOk);
if (!uidOk) { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("area")) {
2017-12-12 04:45:46 +01:00
if (jsonObject["area"].isString()) { localProperties.location.area = jsonObject["area"].toString(); }
else { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("crewid")) {
bool crewIDOk;
2017-12-12 04:45:46 +01:00
localProperties.crewID = jsonMap["crewid"].toInt(&crewIDOk);
if (!crewIDOk) { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("street")) {
bool streetIDOk;
2017-12-12 04:45:46 +01:00
localProperties.streetID = jsonMap["street"].toInt(&streetIDOk);
if (!streetIDOk) { jsonError = true; }
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("creat")) {
bool timestampOk;
2017-10-09 08:35:48 +02:00
QDateTime createdTimestamp;
2017-12-12 04:45:46 +01:00
localProperties.createdTimestamp = jsonMap["creat"].toUInt(&timestampOk);
2020-09-28 05:33:04 +02:00
#if QT_VERSION >= 0x060000
2020-11-05 18:32:20 +01:00
createdTimestamp.setSecsSinceEpoch(localProperties.createdTimestamp);
2020-09-28 05:33:04 +02:00
#else
2017-12-12 04:45:46 +01:00
createdTimestamp.setTime_t(localProperties.createdTimestamp);
2020-09-28 05:33:04 +02:00
#endif
2017-12-12 04:45:46 +01:00
localProperties.createdDateTime = createdTimestamp;
if (!timestampOk) { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("plyrs")) {
2017-12-12 04:45:46 +01:00
if (jsonObject["plyrs"].isArray()) { localProperties.playersList = jsonMap["plyrs"].toStringList(); }
else { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
2017-12-12 04:45:46 +01:00
// else { jsonIncomplete = true; } // 2016 Snapmatic pictures left out plyrs when none are captured, so don't force exists on that one
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("meme")) {
2017-12-12 04:45:46 +01:00
if (jsonObject["meme"].isBool()) { localProperties.isMeme = jsonObject["meme"].toBool(); }
else { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("mug")) {
2017-12-12 04:45:46 +01:00
if (jsonObject["mug"].isBool()) { localProperties.isMug = jsonObject["mug"].toBool(); }
else { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("slf")) {
2017-12-12 04:45:46 +01:00
if (jsonObject["slf"].isBool()) { localProperties.isSelfie = jsonObject["slf"].toBool(); }
else { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("drctr")) {
2017-12-12 04:45:46 +01:00
if (jsonObject["drctr"].isBool()) { localProperties.isFromDirector = jsonObject["drctr"].toBool(); }
else { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
else { jsonIncomplete = true; }
2021-02-15 23:12:44 +01:00
if (jsonObject.contains("rsedtr")) {
2017-12-12 04:45:46 +01:00
if (jsonObject["rsedtr"].isBool()) { localProperties.isFromRSEditor = jsonObject["rsedtr"].toBool(); }
else { jsonError = true; }
2017-10-09 08:35:48 +02:00
}
2021-02-15 23:12:44 +01:00
else { localProperties.isFromRSEditor = false; }
if (jsonObject.contains("onislandx")) {
if (jsonObject["onislandx"].isBool()) { localProperties.location.isCayoPerico = jsonObject["onislandx"].toBool(); }
else { jsonError = true; }
}
else { localProperties.location.isCayoPerico = false; }
2017-10-09 08:35:48 +02:00
2021-02-15 23:12:44 +01:00
if (!jsonIncomplete && !jsonError) {
jsonOk = true;
}
2021-02-15 23:12:44 +01:00
else {
if (jsonIncomplete && jsonError) {
lastStep = "2;/4,ReadingFile," % convertDrawStringForLog(picFilePath) % ",3,JSONINCOMPLETE,JSONERROR";
2017-12-12 04:45:46 +01:00
}
2021-02-15 23:12:44 +01:00
else if (jsonIncomplete) {
lastStep = "2;/3,ReadingFile," % convertDrawStringForLog(picFilePath) % ",3,JSONINCOMPLETE";
2017-12-12 04:45:46 +01:00
}
2021-02-15 23:12:44 +01:00
else if (jsonError) {
lastStep = "2;/3,ReadingFile," % convertDrawStringForLog(picFilePath) % ",3,JSONERROR";
2017-12-12 04:45:46 +01:00
}
jsonOk = false;
}
2017-10-09 08:35:48 +02:00
}
2017-12-12 04:45:46 +01:00
bool SnapmaticPicture::setSnapmaticProperties(SnapmaticProperties properties)
2017-10-09 08:35:48 +02:00
{
2020-11-15 12:29:33 +01:00
QJsonObject jsonObject = p_ragePhoto.jsonObject();
2017-10-09 08:35:48 +02:00
QJsonObject locObject;
2017-12-12 04:45:46 +01:00
locObject["x"] = properties.location.x;
locObject["y"] = properties.location.y;
locObject["z"] = properties.location.z;
2017-10-09 08:35:48 +02:00
jsonObject["loc"] = locObject;
2017-12-12 04:45:46 +01:00
jsonObject["uid"] = properties.uid;
jsonObject["area"] = properties.location.area;
jsonObject["crewid"] = properties.crewID;
jsonObject["street"] = properties.streetID;
jsonObject["creat"] = QJsonValue::fromVariant(properties.createdTimestamp);
jsonObject["plyrs"] = QJsonValue::fromVariant(properties.playersList);
jsonObject["meme"] = properties.isMeme;
jsonObject["mug"] = properties.isMug;
jsonObject["slf"] = properties.isSelfie;
jsonObject["drctr"] = properties.isFromDirector;
jsonObject["rsedtr"] = properties.isFromRSEditor;
2021-02-15 23:12:44 +01:00
jsonObject["onislandx"] = properties.location.isCayoPerico;
2017-10-09 08:35:48 +02:00
QJsonDocument jsonDocument(jsonObject);
2021-02-15 23:12:44 +01:00
if (setJsonStr(QString::fromUtf8(jsonDocument.toJson(QJsonDocument::Compact)))) {
2017-12-12 04:45:46 +01:00
localProperties = properties;
2017-10-09 08:35:48 +02:00
return true;
}
return false;
}
bool SnapmaticPicture::setJsonStr(const QString &newJsonStr, bool updateProperties)
2017-10-09 08:35:48 +02:00
{
2020-11-15 12:29:33 +01:00
if (p_ragePhoto.setJsonData(newJsonStr.toUtf8())) {
if (updateProperties)
parseJsonContent();
return true;
}
else {
return false;
2017-10-09 08:35:48 +02:00
}
}
// FILE MANAGEMENT
bool SnapmaticPicture::exportPicture(const QString &fileName, SnapmaticFormat format_)
{
// Keep current format when Auto_Format is used
SnapmaticFormat format = format_;
2021-02-15 23:12:44 +01:00
if (format_ == SnapmaticFormat::Auto_Format) {
if (p_ragePhoto.photoFormat() == RagePhoto::PhotoFormat::G5EX) {
format = SnapmaticFormat::G5E_Format;
}
2021-02-15 23:12:44 +01:00
else {
format = SnapmaticFormat::PGTA_Format;
}
}
bool saveSuccess = false;
#if QT_VERSION >= 0x050000
QSaveFile *picFile = new QSaveFile(fileName);
#else
QFile *picFile = new QFile(StandardPaths::tempLocation() % "/" % QFileInfo(fileName).fileName() % ".tmp");
#endif
2021-02-15 23:12:44 +01:00
if (picFile->open(QIODevice::WriteOnly)) {
if (format == SnapmaticFormat::G5E_Format) {
2020-11-15 12:29:33 +01:00
p_ragePhoto.save(picFile, RagePhoto::PhotoFormat::G5EX);
#if QT_VERSION >= 0x050000
saveSuccess = picFile->commit();
#else
saveSuccess = true;
picFile->close();
#endif
delete picFile;
}
2021-02-15 23:12:44 +01:00
else if (format == SnapmaticFormat::JPEG_Format) {
2020-11-15 12:29:33 +01:00
picFile->write(p_ragePhoto.photoData());
#if QT_VERSION >= 0x050000
saveSuccess = picFile->commit();
#else
saveSuccess = true;
picFile->close();
#endif
delete picFile;
}
2021-02-15 23:12:44 +01:00
else {
2020-11-15 12:29:33 +01:00
p_ragePhoto.save(picFile, RagePhoto::PhotoFormat::GTA5);
#if QT_VERSION >= 0x050000
saveSuccess = picFile->commit();
#else
saveSuccess = true;
picFile->close();
#endif
delete picFile;
}
#if QT_VERSION <= 0x050000
if (saveSuccess) {
bool tempBakCreated = false;
if (QFile::exists(fileName)) {
if (!QFile::rename(fileName, fileName % ".tmp")) {
QFile::remove(StandardPaths::tempLocation() % "/" % QFileInfo(fileName).fileName() % ".tmp");
return false;
}
tempBakCreated = true;
}
if (!QFile::rename(StandardPaths::tempLocation() % "/" % QFileInfo(fileName).fileName() % ".tmp", fileName)) {
QFile::remove(StandardPaths::tempLocation() % "/" % QFileInfo(fileName).fileName() % ".tmp");
if (tempBakCreated)
QFile::rename(fileName % ".tmp", fileName);
return false;
}
if (tempBakCreated)
QFile::remove(fileName % ".tmp");
}
#endif
return saveSuccess;
}
2021-02-15 23:12:44 +01:00
else {
delete picFile;
return saveSuccess;
}
2017-10-09 08:35:48 +02:00
}
void SnapmaticPicture::setPicFileName(const QString &picFileName_)
{
picFileName = picFileName_;
}
void SnapmaticPicture::setPicFilePath(const QString &picFilePath_)
{
picFilePath = picFilePath_;
}
bool SnapmaticPicture::deletePicFile()
{
2020-11-05 18:32:20 +01:00
bool success = false;
2021-02-15 23:12:44 +01:00
if (!QFile::exists(picFilePath)) {
2020-11-05 18:32:20 +01:00
success = true;
}
2021-02-15 23:12:44 +01:00
else if (QFile::remove(picFilePath)) {
2020-11-05 18:32:20 +01:00
success = true;
}
2021-02-15 23:12:44 +01:00
if (isHidden()) {
2020-11-05 18:32:20 +01:00
const QString picBakPath = QString(picFilePath).remove(picFilePath.length() - 7, 7) % ".bak";
if (QFile::exists(picBakPath)) QFile::remove(picBakPath);
}
else {
const QString picBakPath = picFilePath % ".bak";
if (QFile::exists(picBakPath)) QFile::remove(picBakPath);
}
return success;
2017-10-09 08:35:48 +02:00
}
// VISIBILITY
bool SnapmaticPicture::isHidden()
{
2021-02-15 23:12:44 +01:00
if (picFilePath.right(7) == QLatin1String(".hidden")) {
2017-10-09 08:35:48 +02:00
return true;
}
return false;
}
2017-12-12 04:45:46 +01:00
bool SnapmaticPicture::isVisible()
{
2021-02-15 23:12:44 +01:00
if (picFilePath.right(7) == QLatin1String(".hidden")) {
2017-12-12 04:45:46 +01:00
return false;
}
return true;
}
2017-10-09 08:35:48 +02:00
bool SnapmaticPicture::setPictureHidden()
{
2021-02-15 23:12:44 +01:00
if (p_ragePhoto.photoFormat() == RagePhoto::PhotoFormat::G5EX) {
2017-10-09 08:35:48 +02:00
return false;
}
2021-02-15 23:12:44 +01:00
if (!isHidden()) {
2017-10-09 08:35:48 +02:00
QString newPicFilePath = QString(picFilePath % ".hidden");
2021-02-15 23:12:44 +01:00
if (QFile::rename(picFilePath, newPicFilePath)) {
2017-10-09 08:35:48 +02:00
picFilePath = newPicFilePath;
return true;
}
return false;
}
return true;
}
bool SnapmaticPicture::setPictureVisible()
{
2021-02-15 23:12:44 +01:00
if (p_ragePhoto.photoFormat() == RagePhoto::PhotoFormat::G5EX) {
2017-10-09 08:35:48 +02:00
return false;
}
2021-02-15 23:12:44 +01:00
if (isHidden()) {
2017-10-09 08:35:48 +02:00
QString newPicFilePath = QString(picFilePath).remove(picFilePath.length() - 7, 7);
2021-02-15 23:12:44 +01:00
if (QFile::rename(picFilePath, newPicFilePath)) {
2017-10-09 08:35:48 +02:00
picFilePath = newPicFilePath;
return true;
}
return false;
}
return true;
}
// PREDEFINED PROPERTIES
QSize SnapmaticPicture::getSnapmaticResolution()
{
return snapmaticResolution;
}
// SNAPMATIC FORMAT
SnapmaticFormat SnapmaticPicture::getSnapmaticFormat()
{
2021-02-15 23:12:44 +01:00
if (p_ragePhoto.photoFormat() == RagePhoto::PhotoFormat::G5EX) {
return SnapmaticFormat::G5E_Format;
}
return SnapmaticFormat::PGTA_Format;
}
void SnapmaticPicture::setSnapmaticFormat(SnapmaticFormat format)
{
2021-02-15 23:12:44 +01:00
if (format == SnapmaticFormat::G5E_Format) {
2020-11-15 12:29:33 +01:00
p_ragePhoto.setPhotoFormat(RagePhoto::PhotoFormat::G5EX);
return;
}
2021-02-15 23:12:44 +01:00
else if (format == SnapmaticFormat::PGTA_Format) {
2020-11-15 12:29:33 +01:00
p_ragePhoto.setPhotoFormat(RagePhoto::PhotoFormat::GTA5);
return;
}
qDebug() << "setSnapmaticFormat: Invalid SnapmaticFormat defined, valid SnapmaticFormats are G5E_Format and PGTA_Format";
}
bool SnapmaticPicture::isFormatSwitched()
{
return isFormatSwitch;
}
2017-10-09 08:35:48 +02:00
// VERIFY CONTENT
bool SnapmaticPicture::verifyTitle(const QString &title)
{
// VERIFY TITLE FOR BE A VALID SNAPMATIC TITLE
2021-02-15 23:12:44 +01:00
if (title.length() <= 39 && title.length() > 0) {
for (const QChar &titleChar : title) {
2017-10-09 08:35:48 +02:00
if (!verifyTitleChar(titleChar)) return false;
}
return true;
}
return false;
}
bool SnapmaticPicture::verifyTitleChar(const QChar &titleChar)
{
// VERIFY CHAR FOR BE A VALID SNAPMATIC CHARACTER
2021-02-15 23:12:44 +01:00
if (titleChar.isLetterOrNumber() || titleChar.isPrint()) {
2017-10-09 08:35:48 +02:00
if (titleChar == '<' || titleChar == '>' || titleChar == '\\') return false;
return true;
}
return false;
}
// STRING OPERATIONS
QString SnapmaticPicture::parseTitleString(const QByteArray &commitBytes, int maxLength)
{
Q_UNUSED(maxLength)
2020-09-28 05:33:04 +02:00
#if QT_VERSION >= 0x060000
QStringDecoder strDecoder = QStringDecoder(QStringDecoder::Utf16LE);
QString retStr = strDecoder(commitBytes);
2020-10-11 17:46:45 +02:00
retStr = retStr.trimmed();
2020-09-28 05:33:04 +02:00
#else
QString retStr = QTextCodec::codecForName("UTF-16LE")->toUnicode(commitBytes).trimmed();
2020-09-28 05:33:04 +02:00
#endif
retStr.remove(QChar('\x00'));
return retStr;
}
QString SnapmaticPicture::convertDrawStringForLog(const QString &inputStr)
{
QString outputStr = inputStr;
return outputStr.replace("&","&u;").replace(",", "&c;");
}
QString SnapmaticPicture::convertLogStringForDraw(const QString &inputStr)
{
QString outputStr = inputStr;
return outputStr.replace("&c;",",").replace("&u;", "&");
}
2020-11-15 12:29:33 +01:00
// RAGEPHOTO
RagePhoto* SnapmaticPicture::ragePhoto()
{
return &p_ragePhoto;
}