Gurkengewuerz
/
KShare
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add clang-format; Make text and blur less annoying 

I didn't read the clang-format documentation properly
This commit is contained in:
ArsenArsen 2017-05-09 17:26:00 +02:00
parent 7737b77671
commit 37ce6f1eda
43 changed files with 1079 additions and 1077 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
.clang-format Normal file
View File

@ -0,0 +1,47 @@
AccessModifierOffset: 0
AlignEscapedNewlinesLeft: false
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortFunctionsOnASingleLine: false
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: true
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: false
BinPackParameters: false
BreakBeforeBinaryOperators: true
BreakBeforeBraces: Attach
BreakBeforeTernaryOperators: false
BreakConstructorInitializersBeforeComma: false
ColumnLimit: 120
CommentPragmas: ''
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 0
ContinuationIndentWidth: 0
Cpp11BracedListStyle: false
DerivePointerBinding: false
IndentCaseLabels: false
IndentFunctionDeclarationAfterType: false
IndentWidth: 4
Language: Cpp
MaxEmptyLinesToKeep: 2
NamespaceIndentation: None
ObjCSpaceAfterProperty: true
ObjCSpaceBeforeProtocolList: true
PenaltyBreakBeforeFirstCallParameter: 100
PenaltyBreakComment: 100
PenaltyBreakFirstLessLess: 0
PenaltyBreakString: 100
PenaltyExcessCharacter: 1
PenaltyReturnTypeOnItsOwnLine: 20
PointerBindsToType: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInContainerLiterals: false
SpacesInParentheses: false
Standard: Auto
TabWidth: 4
UseTab: Never

38
cropeditor/cropeditor.cpp
View File

@ -9,28 +9,30 @@
#include <settings.hpp> #include <settings.hpp>
CropEditor::CropEditor(QPixmap *image, QObject *parent) : QObject(parent) { CropEditor::CropEditor(QPixmap *image, QObject *parent) : QObject(parent) {
scene = new CropScene(parent, image); scene = new CropScene(parent, image);
view = new CropView(scene); view = new CropView(scene);
QPixmap *scaled = new QPixmap(); QPixmap *scaled = new QPixmap();
image->scaled(view->width(), view->height()).swap(*scaled); image->scaled(view->width(), view->height()).swap(*scaled);
pixmapItem = new QGraphicsPixmapItem(*image); pixmapItem = new QGraphicsPixmapItem(*image);
pixmapItem->setZValue(-1); pixmapItem->setZValue(-1);
scene->addItem(pixmapItem); scene->addItem(pixmapItem);
scene->setSceneRect(image->rect()); scene->setSceneRect(image->rect());
view->setGeometry(0, 0, image->width(), image->height()); view->setGeometry(0, 0, image->width(), image->height());
view->showFullScreen(); view->showFullScreen();
QTimer::singleShot(0, [&] { view->showFullScreen(); }); QTimer::singleShot(0, [&] { view->showFullScreen(); });
connect(scene, &CropScene::closedWithRect, this, &CropEditor::crop); connect(scene, &CropScene::closedWithRect, this, &CropEditor::crop);
} }
CropEditor::~CropEditor() { delete scene; } CropEditor::~CropEditor() {
delete scene;
}
void CropEditor::crop(QRect rect) { void CropEditor::crop(QRect rect) {
QPixmap map = view->grab(rect); QPixmap map = view->grab(rect);
QPixmap *cropp = new QPixmap; QPixmap *cropp = new QPixmap;
map.swap(*cropp); map.swap(*cropp);
delete view; delete view;
emit cropped(cropp); emit cropped(cropp);
} }

22
cropeditor/cropeditor.hpp
View File

@ -9,18 +9,18 @@
#include <QPixmap> #include <QPixmap>
class CropEditor : public QObject { class CropEditor : public QObject {
Q_OBJECT Q_OBJECT
public: public:
CropEditor(QPixmap *image, QObject *parent = 0); CropEditor(QPixmap *image, QObject *parent = 0);
~CropEditor(); ~CropEditor();
signals: signals:
QPixmap *cropped(QPixmap *pixmap); QPixmap *cropped(QPixmap *pixmap);
private: private:
void crop(QRect rect); void crop(QRect rect);
CropScene *scene = nullptr; CropScene *scene = nullptr;
CropView *view = nullptr; CropView *view = nullptr;
QGraphicsPixmapItem *pixmapItem = nullptr; QGraphicsPixmapItem *pixmapItem = nullptr;
}; };
#endif // CROPEDITOR_HPP #endif // CROPEDITOR_HPP

240
cropeditor/cropscene.cpp
View File

@ -17,162 +17,154 @@
#include <settings.hpp> #include <settings.hpp>
CropScene::CropScene(QObject *parent, QPixmap *pixmap) CropScene::CropScene(QObject *parent, QPixmap *pixmap)
: QGraphicsScene(parent), prevButtons(Qt::NoButton), : QGraphicsScene(parent), drawingSelectionMaker([] { return nullptr; }), prevButtons(Qt::NoButton),
drawingSelectionMaker([] { return nullptr; }), _font(settings::settings().value("font", QFont()).value<QFont>()) {
_font(settings::settings().value("font", QFont()).value<QFont>()) { pen().setColor(settings::settings().value("penColor", pen().color()).value<QColor>());
pen().setColor( pen().setCosmetic(settings::settings().value("penCosmetic", pen().isCosmetic()).toBool());
settings::settings().value("penColor", pen().color()).value<QColor>()); pen().setWidthF(settings::settings().value("penWidth", pen().widthF()).toFloat());
pen().setCosmetic( brush().setColor(settings::settings().value("brushColor", brush().color()).value<QColor>());
settings::settings().value("penCosmetic", pen().isCosmetic()).toBool());
pen().setWidthF(
settings::settings().value("penWidth", pen().widthF()).toFloat());
brush().setColor(settings::settings()
.value("brushColor", brush().color())
.value<QColor>());
addDrawingAction(menu, "Dot", [] { return new DotItem; }); addDrawingAction(menu, "Dot", [] { return new DotItem; });
addDrawingAction(menu, "Path", [] { return new PathItem; }); addDrawingAction(menu, "Path", [] { return new PathItem; });
addDrawingAction(menu, "Blur", [] { return new BlurItem; }); addDrawingAction(menu, "Blur", [] { return new BlurItem; });
addDrawingAction(menu, "Straight line", [] { return new LineItem; }); addDrawingAction(menu, "Straight line", [] { return new LineItem; });
addDrawingAction(menu, "Text", [] { return new TextItem; }); addDrawingAction(menu, "Text", [] { return new TextItem; });
QAction *reset = menu.addAction("Reset"); QAction *reset = menu.addAction("Reset");
connect(reset, &QAction::triggered, connect(reset, &QAction::triggered, [&] { setDrawingSelection("None", [] { return nullptr; }); });
[&] { setDrawingSelection("None", [] { return nullptr; }); });
menu.addSeparator(); menu.addSeparator();
QAction *settings = new QAction; QAction *settings = new QAction;
settings->setText("Settings"); settings->setText("Settings");
menu.addSeparator(); menu.addSeparator();
display = menu.addAction(drawingName); display = menu.addAction(drawingName);
display->setDisabled(true); display->setDisabled(true);
connect(settings, &QAction::triggered, connect(settings, &QAction::triggered, [&] { BrushPenSelection(this).exec(); });
[&] { BrushPenSelection(this).exec(); }); menu.addAction(settings);
menu.addAction(settings);
connect(menu.addAction("Set Font"), &QAction::triggered, this, connect(menu.addAction("Set Font"), &QAction::triggered, this, &CropScene::fontAsk);
&CropScene::fontAsk);
_pixmap = pixmap; _pixmap = pixmap;
QTimer::singleShot(0, [&] { QTimer::singleShot(0, [&] {
QPolygonF poly; QPolygonF poly;
poly.append(sceneRect().topLeft()); poly.append(sceneRect().topLeft());
poly.append(sceneRect().topRight()); poly.append(sceneRect().topRight());
poly.append(sceneRect().bottomRight()); poly.append(sceneRect().bottomRight());
poly.append(sceneRect().bottomLeft()); poly.append(sceneRect().bottomLeft());
polyItem = new QGraphicsPolygonItem(poly); polyItem = new QGraphicsPolygonItem(poly);
polyItem->setBrush(QBrush(QColor(0, 0, 0, 191))); polyItem->setBrush(QBrush(QColor(0, 0, 0, 191)));
polyItem->setPen(QPen(Qt::NoPen)); polyItem->setPen(QPen(Qt::NoPen));
addItem(polyItem); addItem(polyItem);
}); });
} }
CropScene::~CropScene() { delete drawingSelection; } CropScene::~CropScene() {
delete drawingSelection;
}
QPen &CropScene::pen() { return _pen; } QPen &CropScene::pen() {
return _pen;
}
QBrush &CropScene::brush() { return _brush; } QBrush &CropScene::brush() {
return _brush;
}
QFont &CropScene::font() { return _font; } QFont &CropScene::font() {
return _font;
}
void CropScene::setDrawingSelection(QString name, void CropScene::setDrawingSelection(QString name, std::function<DrawItem *()> drawAction) {
std::function<DrawItem *()> drawAction) { drawingSelectionMaker = drawAction;
drawingSelectionMaker = drawAction; drawingSelection = drawAction();
drawingSelection = drawAction(); drawingName = name;
drawingName = name; if (drawingSelection)
if (drawingSelection) if (!drawingSelection->init(this)) setDrawingSelection("None", [] { return nullptr; });
drawingSelection->init(this);
} }
void CropScene::fontAsk() { void CropScene::fontAsk() {
bool ok = false; bool ok = false;
QFont font = QFontDialog::getFont(&ok, this->font(), nullptr, "Font to use"); QFont font = QFontDialog::getFont(&ok, this->font(), nullptr, "Font to use");
if (ok) if (ok) _font = font;
_font = font;
} }
void CropScene::mouseMoveEvent(QGraphicsSceneMouseEvent *e) { void CropScene::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
auto buttons = e->buttons(); auto buttons = e->buttons();
if (buttons == Qt::LeftButton || prevButtons == Qt::NoButton) { if (buttons == Qt::LeftButton || prevButtons == Qt::NoButton) {
if (drawingSelection) { if (drawingSelection) {
drawingSelection->mouseDragEvent(e, this); drawingSelection->mouseDragEvent(e, this);
} else {
QPointF p = e->scenePos();
if (rect == nullptr) {
rect = new QGraphicsRectItem(p.x(), p.y(), 1, 1);
initPos = p;
QPen pen(Qt::NoBrush, 1);
pen.setColor(Qt::cyan);
rect->setPen(pen);
addItem(rect);
} else {
if (prevButtons == Qt::NoButton) {
initPos = p;
rect->setRect(p.x(), p.y(), 1, 1);
} else { } else {
rect->setRect( QPointF p = e->scenePos();
QRect(qMin(initPos.x(), p.x()), qMin(initPos.y(), p.y()), if (rect == nullptr) {
qAbs(initPos.x() - p.x()), qAbs(initPos.y() - p.y()))); rect = new QGraphicsRectItem(p.x(), p.y(), 1, 1);
} initPos = p;
} QPen pen(Qt::NoBrush, 1);
QPolygonF poly; pen.setColor(Qt::cyan);
QPointF theMagicWikipediaPoint(rect->rect().right(), rect->setPen(pen);
sceneRect().bottom()); addItem(rect);
poly << sceneRect().topLeft(); } else {
poly << sceneRect().topRight(); if (prevButtons == Qt::NoButton) {
poly << sceneRect().bottomRight(); initPos = p;
poly << theMagicWikipediaPoint; rect->setRect(p.x(), p.y(), 1, 1);
poly << rect->rect().bottomRight(); } else {
poly << rect->rect().topRight(); rect->setRect(QRect(qMin(initPos.x(), p.x()), qMin(initPos.y(), p.y()), qAbs(initPos.x() - p.x()),
poly << rect->rect().topLeft(); qAbs(initPos.y() - p.y())));
poly << rect->rect().bottomLeft(); }
poly << rect->rect().bottomRight(); }
poly << theMagicWikipediaPoint; QPolygonF poly;
poly << sceneRect().bottomLeft(); QPointF theMagicWikipediaPoint(rect->rect().right(), sceneRect().bottom());
poly << sceneRect().topLeft(); poly << sceneRect().topLeft();
poly << sceneRect().topRight();
poly << sceneRect().bottomRight();
poly << theMagicWikipediaPoint;
poly << rect->rect().bottomRight();
poly << rect->rect().topRight();
poly << rect->rect().topLeft();
poly << rect->rect().bottomLeft();
poly << rect->rect().bottomRight();
poly << theMagicWikipediaPoint;
poly << sceneRect().bottomLeft();
poly << sceneRect().topLeft();
this->polyItem->setPolygon(poly); this->polyItem->setPolygon(poly);
e->accept(); e->accept();
}
} }
} prevButtons = buttons;
prevButtons = buttons;
} }
void CropScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) { void CropScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
qDebug() << "release"; qDebug() << "release";
if (drawingSelection) { if (drawingSelection) {
drawingSelection->mouseDragEndEvent(e, this); drawingSelection->mouseDragEndEvent(e, this);
delete drawingSelection; delete drawingSelection;
drawingSelection = drawingSelectionMaker(); drawingSelection = drawingSelectionMaker();
if (drawingSelection) if (drawingSelection)
drawingSelection->init(this); if (!drawingSelection->init(this)) setDrawingSelection("None", [] { return nullptr; });
} }
prevButtons = Qt::NoButton; prevButtons = Qt::NoButton;
} }
void CropScene::addDrawingAction(QMenu &menu, QString name, void CropScene::addDrawingAction(QMenu &menu, QString name, std::function<DrawItem *()> item) {
std::function<DrawItem *()> item) { QAction *action = new QAction;
QAction *action = new QAction; action->setText(name);
action->setText(name); connect(action, &QAction::triggered, [this, item, name](bool) { setDrawingSelection(name, item); });
connect(action, &QAction::triggered, menu.addAction(action);
[this, item, name](bool) { setDrawingSelection(name, item); });
menu.addAction(action);
} }
void CropScene::contextMenuEvent(QGraphicsSceneContextMenuEvent *e) { void CropScene::contextMenuEvent(QGraphicsSceneContextMenuEvent *e) {
display->setText(drawingName); display->setText(drawingName);
menu.exec(e->screenPos()); menu.exec(e->screenPos());
e->accept(); e->accept();
} }
void CropScene::keyReleaseEvent(QKeyEvent *event) { void CropScene::keyReleaseEvent(QKeyEvent *event) {
if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) done(); // Segfault
done(); // Segfault
} }
void CropScene::done() { void CropScene::done() {
if (rect) { if (rect) {
rect->setPen(QPen(Qt::NoPen)); rect->setPen(QPen(Qt::NoPen));
emit closedWithRect(rect->rect().toRect()); emit closedWithRect(rect->rect().toRect());
} }
} }

72
cropeditor/cropscene.hpp
View File

@ -14,47 +14,47 @@ class CropScene;
#include <cropeditor/drawing/drawitem.hpp> #include <cropeditor/drawing/drawitem.hpp>
class CropScene : public QGraphicsScene { class CropScene : public QGraphicsScene {
Q_OBJECT Q_OBJECT
public: public:
CropScene(QObject *parent, QPixmap *pixmap); CropScene(QObject *parent, QPixmap *pixmap);
~CropScene(); ~CropScene();
QPen &pen(); QPen &pen();
QBrush &brush(); QBrush &brush();
QFont &font(); QFont &font();
void setDrawingSelection(QString name, void setDrawingSelection(QString name, std::function<DrawItem *()> drawAction);
std::function<DrawItem *()> drawAction); QPixmap *pixmap() {
QPixmap *pixmap() { return _pixmap; } return _pixmap;
}
public slots: public slots:
void fontAsk(); void fontAsk();
signals: signals:
void closedWithRect(QRect rect); void closedWithRect(QRect rect);
protected: protected:
void mouseMoveEvent(QGraphicsSceneMouseEvent *e) override; void mouseMoveEvent(QGraphicsSceneMouseEvent *e) override;
void mouseReleaseEvent(QGraphicsSceneMouseEvent *e) override; void mouseReleaseEvent(QGraphicsSceneMouseEvent *e) override;
void contextMenuEvent(QGraphicsSceneContextMenuEvent *e) override; void contextMenuEvent(QGraphicsSceneContextMenuEvent *e) override;
void keyReleaseEvent(QKeyEvent *e) override; void keyReleaseEvent(QKeyEvent *e) override;
private: private:
void addDrawingAction(QMenu &menu, QString name, void addDrawingAction(QMenu &menu, QString name, std::function<DrawItem *()> item);
std::function<DrawItem *()> item); void done();
void done(); std::function<DrawItem *()> drawingSelectionMaker;
std::function<DrawItem *()> drawingSelectionMaker; QFlags<Qt::MouseButton> prevButtons;
QFlags<Qt::MouseButton> prevButtons; QPixmap *_pixmap;
QPixmap *_pixmap; QGraphicsRectItem *rect = nullptr;
QGraphicsRectItem *rect = nullptr; QPointF initPos;
QPointF initPos; QPen _pen;
QPen _pen; QBrush _brush;
QBrush _brush; QFont _font;
QFont _font; QGraphicsPolygonItem *polyItem = nullptr;
QGraphicsPolygonItem *polyItem = nullptr; DrawItem *drawingSelection = nullptr;
DrawItem *drawingSelection = nullptr; QMenu menu;
QMenu menu; QString drawingName = "None";
QString drawingName = "None"; QAction *display;
QAction *display;
}; };
#endif // CROPSCENE_HPP #endif // CROPSCENE_HPP

26
cropeditor/cropview.cpp
View File

@ -1,21 +1,19 @@
#include "cropview.hpp" #include "cropview.hpp"
CropView::CropView(QGraphicsScene *scene) : QGraphicsView(scene) { CropView::CropView(QGraphicsScene *scene) : QGraphicsView(scene) {
setFrameShape( setFrameShape(QFrame::NoFrame); // Time taken to solve: A george99g and 38 minutes.
QFrame::NoFrame); // Time taken to solve: A george99g and 38 minutes. setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setWindowFlags(Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint);
setWindowFlags(Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint); setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing);
setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform | setCursor(QCursor(Qt::CrossCursor));
QPainter::HighQualityAntialiasing);
setCursor(QCursor(Qt::CrossCursor));
} }
void CropView::keyPressEvent(QKeyEvent *e) { void CropView::keyPressEvent(QKeyEvent *e) {
if (e->key() == Qt::Key_Escape) { if (e->key() == Qt::Key_Escape) {
close(); close();
e->accept(); e->accept();
return; return;
} }
QGraphicsView::keyPressEvent(e); QGraphicsView::keyPressEvent(e);
} }

8
cropeditor/cropview.hpp
View File

@ -5,11 +5,11 @@
#include <QKeyEvent> #include <QKeyEvent>
class CropView : public QGraphicsView { class CropView : public QGraphicsView {
public: public:
CropView(QGraphicsScene *scene); CropView(QGraphicsScene *scene);
protected: protected:
void keyPressEvent(QKeyEvent *e) override; void keyPressEvent(QKeyEvent *e) override;
}; };
#endif // CROPVIEW_HPP #endif // CROPVIEW_HPP

37
cropeditor/drawing/bluritem.cpp
View File

@ -3,30 +3,27 @@
#include <QDebug> #include <QDebug>
#include <cropeditor/settings/blurdialog.hpp> #include <cropeditor/settings/blurdialog.hpp>
void BlurItem::init(CropScene *) { bool BlurItem::init(CropScene *) {
effect = new QGraphicsBlurEffect; effect = new QGraphicsBlurEffect;
BlurDialog(effect).exec(); return BlurDialog(effect).exec();
} }
void BlurItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) { void BlurItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) {
if (pos.isNull()) { if (pos.isNull()) {
pos = e->scenePos(); pos = e->scenePos();
rect = scene->addRect(QRect(e->scenePos().toPoint(), QSize(1, 1)), rect = scene->addRect(QRect(e->scenePos().toPoint(), QSize(1, 1)), QPen(Qt::cyan), Qt::NoBrush);
QPen(Qt::cyan), Qt::NoBrush); pixmap = scene->addPixmap(scene->pixmap()->copy(rect->rect().toRect()));
pixmap = scene->addPixmap(scene->pixmap()->copy(rect->rect().toRect())); pixmap->setPos(e->scenePos());
pixmap->setPos(e->scenePos()); pixmap->setZValue(rect->zValue() - 0.1);
pixmap->setZValue(rect->zValue() - 0.1); pixmap->setGraphicsEffect(effect);
pixmap->setGraphicsEffect(effect); } else {
} else { QPointF p = e->scenePos();
QPointF p = e->scenePos(); rect->setRect(QRect(qMin(pos.x(), p.x()), qMin(pos.y(), p.y()), qAbs(pos.x() - p.x()), qAbs(pos.y() - p.y())));
rect->setRect(QRect(qMin(pos.x(), p.x()), qMin(pos.y(), p.y()), pixmap->setPixmap(scene->pixmap()->copy(rect->rect().toRect()));
qAbs(pos.x() - p.x()), qAbs(pos.y() - p.y()))); pixmap->setPos(rect->rect().topLeft());
pixmap->setPixmap(scene->pixmap()->copy(rect->rect().toRect())); }
pixmap->setPos(rect->rect().topLeft());
}
} }
void BlurItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) { void BlurItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {
if (rect != nullptr) if (rect != nullptr) rect->setPen(Qt::NoPen);
rect->setPen(Qt::NoPen);
} }

25
cropeditor/drawing/bluritem.hpp
View File

@ -6,19 +6,22 @@
#include <QGraphicsEffect> #include <QGraphicsEffect>
class BlurItem : public DrawItem { class BlurItem : public DrawItem {
public: public:
QString name() { return "Blur"; } QString name() {
~BlurItem() {} return "Blur";
}
~BlurItem() {
}
void init(CropScene *) override; bool init(CropScene *) override;
void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) override; void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) override;
void mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) override; void mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) override;
private: private:
QGraphicsBlurEffect *effect; QGraphicsBlurEffect *effect;
QPointF pos; QPointF pos;
QGraphicsRectItem *rect; QGraphicsRectItem *rect;
QGraphicsPixmapItem *pixmap; QGraphicsPixmapItem *pixmap;
}; };
#endif // BLURITEM_HPP #endif // BLURITEM_HPP

20
cropeditor/drawing/dotitem.cpp
View File

@ -1,14 +1,14 @@
#include "dotitem.hpp" #include "dotitem.hpp"
DotItem::DotItem() {} DotItem::DotItem() {
DotItem::~DotItem() {}
void DotItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) {
scene
->addEllipse(e->pos().x() - 1.5, e->pos().y() - 1.5, 3, 3, scene->pen(),
scene->brush())
->setPos(e->scenePos());
} }
void DotItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {} DotItem::~DotItem() {
}
void DotItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) {
scene->addEllipse(e->pos().x() - 1.5, e->pos().y() - 1.5, 3, 3, scene->pen(), scene->brush())->setPos(e->scenePos());
}
void DotItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {
}

14
cropeditor/drawing/dotitem.hpp
View File

@ -5,12 +5,14 @@
#include "drawitem.hpp" #include "drawitem.hpp"
class DotItem : public DrawItem { class DotItem : public DrawItem {
public: public:
DotItem(); DotItem();
~DotItem(); ~DotItem();
QString name() { return "Dots (drag to add)"; } QString name() {
void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene); return "Dots (drag to add)";
void mouseDragEndEvent(QGraphicsSceneMouseEvent *e, CropScene *scene); }
void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene);
void mouseDragEndEvent(QGraphicsSceneMouseEvent *e, CropScene *scene);
}; };
#endif // DOTITEM_HPP #endif // DOTITEM_HPP

18
cropeditor/drawing/drawitem.hpp
View File

@ -7,14 +7,16 @@ class DrawItem;
#include <cropeditor/cropscene.hpp> #include <cropeditor/cropscene.hpp>
class DrawItem { class DrawItem {
public: public:
virtual ~DrawItem() {} virtual ~DrawItem() {
virtual QString name() = 0; }
virtual void init(CropScene *scene) { Q_UNUSED(scene) } virtual QString name() = 0;
virtual void mouseDragEvent(QGraphicsSceneMouseEvent *e, virtual bool init(CropScene *scene) {
CropScene *scene) = 0; Q_UNUSED(scene)
virtual void mouseDragEndEvent(QGraphicsSceneMouseEvent *e, return true;
CropScene *scene) = 0; }
virtual void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) = 0;
virtual void mouseDragEndEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) = 0;
}; };
#endif // DRAWITEM_HPP #endif // DRAWITEM_HPP

22
cropeditor/drawing/lineitem.cpp
View File

@ -1,14 +1,16 @@
#include "lineitem.hpp" #include "lineitem.hpp"
LineItem::LineItem() {} LineItem::LineItem() {
void LineItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) {
if (init.isNull()) {
init = e->scenePos();
line = scene->addLine(QLineF(init, init), scene->pen());
} else {
line->setLine(QLineF(init, e->scenePos()));
}
} }
void LineItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {} void LineItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) {
if (init.isNull()) {
init = e->scenePos();
line = scene->addLine(QLineF(init, init), scene->pen());
} else {
line->setLine(QLineF(init, e->scenePos()));
}
}
void LineItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {
}

18
cropeditor/drawing/lineitem.hpp
View File

@ -4,15 +4,17 @@
#include "drawitem.hpp" #include "drawitem.hpp"
class LineItem : public DrawItem { class LineItem : public DrawItem {
public: public:
LineItem(); LineItem();
QString name() override { return "Straight line"; } QString name() override {
void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) override; return "Straight line";
void mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) override; }
void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) override;
void mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) override;
private: private:
QPointF init; QPointF init;
QGraphicsLineItem *line; QGraphicsLineItem *line;
}; };
#endif // LINEITEM_HPP #endif // LINEITEM_HPP

30
cropeditor/drawing/pathitem.cpp
View File

@ -1,17 +1,21 @@
#include "pathitem.hpp" #include "pathitem.hpp"
PathItem::PathItem() {} PathItem::PathItem() {
PathItem::~PathItem() { delete path; }
void PathItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) {
if (path == nullptr) {
path = new QPainterPath(e->scenePos());
pathItem = scene->addPath(*path, scene->pen(), scene->brush());
} else {
path->quadTo(path->currentPosition(), e->scenePos());
pathItem->setPath(*path);
}
} }
void PathItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {} PathItem::~PathItem() {
delete path;
}
void PathItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) {
if (path == nullptr) {
path = new QPainterPath(e->scenePos());
pathItem = scene->addPath(*path, scene->pen(), scene->brush());
} else {
path->quadTo(path->currentPosition(), e->scenePos());
pathItem->setPath(*path);
}
}
void PathItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {
}

20
cropeditor/drawing/pathitem.hpp
View File

@ -5,16 +5,18 @@
#include "drawitem.hpp" #include "drawitem.hpp"
class PathItem : public DrawItem { class PathItem : public DrawItem {
public: public:
PathItem(); PathItem();
~PathItem(); ~PathItem();
QString name() { return "Path"; } QString name() {
void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene); return "Path";
void mouseDragEndEvent(QGraphicsSceneMouseEvent *e, CropScene *scene); }
void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene);
void mouseDragEndEvent(QGraphicsSceneMouseEvent *e, CropScene *scene);
private: private:
QPainterPath *path = nullptr; QPainterPath *path = nullptr;
QGraphicsPathItem *pathItem = nullptr; QGraphicsPathItem *pathItem = nullptr;
}; };
#endif // PATHITEM_HPP #endif // PATHITEM_HPP

34
cropeditor/drawing/textitem.cpp
View File

@ -2,24 +2,28 @@
#include <QInputDialog> #include <QInputDialog>
#include <QtMath> #include <QtMath>
void TextItem::init(CropScene *) { bool TextItem::init(CropScene *) {
text = QInputDialog::getText(nullptr, "Text to add", "Input"); bool ok;
text = QInputDialog::getText(nullptr, "Text to add", "Input", QLineEdit::Normal, QString(), &ok);
return ok;
} }
void TextItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) { void TextItem::mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) {
if (!textItem) { if (!textItem) {
textItem = scene->addSimpleText(text, scene->font()); textItem = scene->addSimpleText(text, scene->font());
textItem->setPos(e->scenePos()); textItem->setPos(e->scenePos());
textItem->setPen(scene->pen()); textItem->setPen(scene->pen());
textItem->setBrush(scene->brush()); textItem->setBrush(scene->brush());
} else { } else {
auto ee = 180 + qRadiansToDegrees( auto ee
qAtan2((textItem->pos().y() - e->scenePos().y()), = 180 + qRadiansToDegrees(qAtan2((textItem->pos().y() - e->scenePos().y()), (textItem->pos().x() - e->scenePos().x())));
(textItem->pos().x() - e->scenePos().x()))); textItem->setRotation(ee);
textItem->setRotation(ee); }
}
} }
void TextItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {} void TextItem::mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) {
}
QString TextItem::name() { return "Text"; } QString TextItem::name() {
return "Text";
}

16
cropeditor/drawing/textitem.hpp
View File

@ -5,15 +5,15 @@
#include <QGraphicsSimpleTextItem> #include <QGraphicsSimpleTextItem>
class TextItem : public DrawItem { class TextItem : public DrawItem {
public: public:
QString name() override; QString name() override;
void init(CropScene *) override; bool init(CropScene *) override;
void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) override; void mouseDragEvent(QGraphicsSceneMouseEvent *e, CropScene *scene) override;
void mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) override; void mouseDragEndEvent(QGraphicsSceneMouseEvent *, CropScene *) override;
private: private:
QGraphicsSimpleTextItem *textItem = nullptr; QGraphicsSimpleTextItem *textItem = nullptr;
QString text; QString text;
}; };
#endif // TEXTITEM_HPP #endif // TEXTITEM_HPP

54
cropeditor/settings/blurdialog.cpp
View File

@ -6,38 +6,38 @@
#include <QDoubleSpinBox> #include <QDoubleSpinBox>
#include <QSlider> #include <QSlider>
BlurDialog::BlurDialog(QGraphicsBlurEffect *e, QWidget *parent) BlurDialog::BlurDialog(QGraphicsBlurEffect *e, QWidget *parent) : QDialog(parent), ui(new Ui::BlurDialog) {
: QDialog(parent), ui(new Ui::BlurDialog) { effect = e;
effect = e; ui->setupUi(this);
ui->setupUi(this); ui->animated->setChecked(effect->blurHints().testFlag(QGraphicsBlurEffect::AnimationHint));
ui->animated->setChecked( ui->performance->setChecked(effect->blurHints().testFlag(QGraphicsBlurEffect::PerformanceHint));
effect->blurHints().testFlag(QGraphicsBlurEffect::AnimationHint)); ui->quality->setChecked(effect->blurHints().testFlag(QGraphicsBlurEffect::QualityHint));
ui->performance->setChecked( ui->radSlider->setValue(effect->blurRadius() * 100);
effect->blurHints().testFlag(QGraphicsBlurEffect::PerformanceHint)); ui->radSpinner->setValue(effect->blurRadius());
ui->quality->setChecked( connect(ui->buttonBox, &QDialogButtonBox::accepted, [&] {
effect->blurHints().testFlag(QGraphicsBlurEffect::QualityHint)); QFlags<QGraphicsBlurEffect::BlurHint> hints;
ui->radSlider->setValue(effect->blurRadius() * 100); hints.setFlag(QGraphicsBlurEffect::AnimationHint, ui->animated->isChecked());
ui->radSpinner->setValue(effect->blurRadius()); hints.setFlag(QGraphicsBlurEffect::PerformanceHint, ui->performance->isChecked());
connect(ui->buttonBox, &QDialogButtonBox::accepted, [&] { hints.setFlag(QGraphicsBlurEffect::QualityHint, ui->quality->isChecked());
QFlags<QGraphicsBlurEffect::BlurHint> hints; effect->setBlurHints(hints);
hints.setFlag(QGraphicsBlurEffect::AnimationHint, effect->setBlurRadius(ui->radSpinner->value());
ui->animated->isChecked()); setResult(QDialog::Accepted);
hints.setFlag(QGraphicsBlurEffect::PerformanceHint, close();
ui->performance->isChecked()); });
hints.setFlag(QGraphicsBlurEffect::QualityHint, ui->quality->isChecked()); connect(ui->buttonBox, &QDialogButtonBox::rejected, [&] {
effect->setBlurHints(hints); setResult(QDialog::Rejected);
effect->setBlurRadius(ui->radSpinner->value()); close();
close(); });
});
connect(ui->buttonBox, &QDialogButtonBox::rejected, [&] { close(); });
} }
BlurDialog::~BlurDialog() { delete ui; } BlurDialog::~BlurDialog() {
delete ui;
}
void BlurDialog::on_radSpinner_valueChanged(double arg1) { void BlurDialog::on_radSpinner_valueChanged(double arg1) {
ui->radSlider->setValue(arg1 * 100); ui->radSlider->setValue(arg1 * 100);
} }
void BlurDialog::on_radSlider_sliderMoved(int position) { void BlurDialog::on_radSlider_sliderMoved(int position) {
ui->radSpinner->setValue(position / 100.); ui->radSpinner->setValue(position / 100.);
} }

20
cropeditor/settings/blurdialog.hpp
View File

@ -9,19 +9,19 @@ class BlurDialog;
} }
class BlurDialog : public QDialog { class BlurDialog : public QDialog {
Q_OBJECT Q_OBJECT
public: public:
explicit BlurDialog(QGraphicsBlurEffect *effect, QWidget *parent = 0); explicit BlurDialog(QGraphicsBlurEffect *effect, QWidget *parent = 0);
~BlurDialog(); ~BlurDialog();
private slots: private slots:
void on_radSpinner_valueChanged(double arg1); void on_radSpinner_valueChanged(double arg1);
void on_radSlider_sliderMoved(int position); void on_radSlider_sliderMoved(int position);
private: private:
Ui::BlurDialog *ui; Ui::BlurDialog *ui;
QGraphicsBlurEffect *effect; QGraphicsBlurEffect *effect;
}; };
#endif // BLURDIALOG_HPP #endif // BLURDIALOG_HPP

51
cropeditor/settings/brushpenselection.cpp
View File

@ -9,45 +9,48 @@
#include <cropeditor/cropview.hpp> #include <cropeditor/cropview.hpp>
#include <settings.hpp> #include <settings.hpp>
BrushPenSelection::BrushPenSelection(CropScene *scene) BrushPenSelection::BrushPenSelection(CropScene *scene) : QDialog(), ui(new Ui::BrushPenSelection) {
: QDialog(), ui(new Ui::BrushPenSelection) { ui->setupUi(this);
ui->setupUi(this); ui->cosmetic->setChecked(scene->pen().isCosmetic());
ui->cosmetic->setChecked(scene->pen().isCosmetic()); ui->widthSlider->setValue(scene->pen().width());
ui->widthSlider->setValue(scene->pen().width()); ui->widthSpinner->setValue(scene->pen().widthF());
ui->widthSpinner->setValue(scene->pen().widthF()); pen = scene->pen().color();
pen = scene->pen().color(); brush = scene->brush().color();
brush = scene->brush().color(); this->scene = scene;
this->scene = scene;
} }
BrushPenSelection::~BrushPenSelection() { delete ui; } BrushPenSelection::~BrushPenSelection() {
delete ui;
}
void BrushPenSelection::on_penColor_clicked(bool) { void BrushPenSelection::on_penColor_clicked(bool) {
pen = QColorDialog::getColor(pen, this, "Pen Color"); pen = QColorDialog::getColor(pen, this, "Pen Color");
} }
void BrushPenSelection::on_brushColor_clicked(bool) { void BrushPenSelection::on_brushColor_clicked(bool) {
brush = QColorDialog::getColor(brush, this, "Brush Color"); brush = QColorDialog::getColor(brush, this, "Brush Color");
} }
void BrushPenSelection::on_buttonBox_accepted() { void BrushPenSelection::on_buttonBox_accepted() {
scene->pen().setColor(pen); scene->pen().setColor(pen);
scene->pen().setCosmetic(ui->cosmetic->isChecked()); scene->pen().setCosmetic(ui->cosmetic->isChecked());
scene->pen().setWidthF(ui->widthSpinner->value()); scene->pen().setWidthF(ui->widthSpinner->value());
scene->brush().setColor(brush); scene->brush().setColor(brush);
settings::settings().setValue("penColor", scene->pen().color()); settings::settings().setValue("penColor", scene->pen().color());
settings::settings().setValue("penCosmetic", scene->pen().isCosmetic()); settings::settings().setValue("penCosmetic", scene->pen().isCosmetic());
settings::settings().setValue("penWidth", scene->pen().widthF()); settings::settings().setValue("penWidth", scene->pen().widthF());
settings::settings().setValue("brushColor", scene->brush().color()); settings::settings().setValue("brushColor", scene->brush().color());
close(); close();
} }
void BrushPenSelection::on_buttonBox_rejected() { close(); } void BrushPenSelection::on_buttonBox_rejected() {
close();
}
void BrushPenSelection::on_widthSlider_sliderMoved(int position) { void BrushPenSelection::on_widthSlider_sliderMoved(int position) {
ui->widthSpinner->setValue(position / 100.); ui->widthSpinner->setValue(position / 100.);
} }
void BrushPenSelection::on_widthSpinner_valueChanged(double arg) { void BrushPenSelection::on_widthSpinner_valueChanged(double arg) {
ui->widthSlider->setValue(arg * 100); ui->widthSlider->setValue(arg * 100);
} }

30
cropeditor/settings/brushpenselection.hpp
View File

@ -9,26 +9,26 @@ class BrushPenSelection;
} }
class BrushPenSelection : public QDialog { class BrushPenSelection : public QDialog {
Q_OBJECT Q_OBJECT
public: public:
explicit BrushPenSelection(CropScene *scene); explicit BrushPenSelection(CropScene *scene);
~BrushPenSelection(); ~BrushPenSelection();
private slots: private slots:
void on_penColor_clicked(bool); void on_penColor_clicked(bool);
void on_brushColor_clicked(bool); void on_brushColor_clicked(bool);
void on_buttonBox_accepted(); void on_buttonBox_accepted();
void on_buttonBox_rejected(); void on_buttonBox_rejected();
void on_widthSlider_sliderMoved(int position); void on_widthSlider_sliderMoved(int position);
void on_widthSpinner_valueChanged(double arg1); void on_widthSpinner_valueChanged(double arg1);
private: private:
Ui::BrushPenSelection *ui; Ui::BrushPenSelection *ui;
CropScene *scene; CropScene *scene;
QColor brush, pen; QColor brush, pen;
}; };
#endif // BRUSHPENSELECTION_HPP #endif // BRUSHPENSELECTION_HPP

19
formatter.cpp
View File

@ -4,14 +4,13 @@
#include <QStringList> #include <QStringList>
QString formatter::format(QString toFormat) { QString formatter::format(QString toFormat) {
QRegExp dateRegex("%\\((.+)\\)date"); QRegExp dateRegex("%\\((.+)\\)date");
dateRegex.indexIn(toFormat); dateRegex.indexIn(toFormat);
QStringList capturedTexts(dateRegex.capturedTexts()); QStringList capturedTexts(dateRegex.capturedTexts());
QString formatted(toFormat); QString formatted(toFormat);
QDateTime date = QDateTime::currentDateTime(); QDateTime date = QDateTime::currentDateTime();
for (int i = 0; i < capturedTexts.length(); i += 2) { for (int i = 0; i < capturedTexts.length(); i += 2) {
formatted = formatted.replace(capturedTexts.at(i), formatted = formatted.replace(capturedTexts.at(i), date.toString(capturedTexts.at(i + 1)));
date.toString(capturedTexts.at(i + 1))); }
} return formatted;
return formatted;
} }

44
hotkeying.cpp
View File

@ -8,38 +8,34 @@
QMap<QString, QHotkey *> hotkeys; QMap<QString, QHotkey *> hotkeys;
// func gets bound only on first set, or load // func gets bound only on first set, or load
void hotkeying::hotkey(QString seqName, QKeySequence seq, void hotkeying::hotkey(QString seqName, QKeySequence seq, std::function<void()> func) {
std::function<void()> func) { if (hotkeys.contains(seqName))
if (hotkeys.contains(seqName)) hotkeys.value(seqName)->setShortcut(seq, true);
hotkeys.value(seqName)->setShortcut(seq, true); else {
else { QHotkey *hotkey = new QHotkey(seq, true);
QHotkey *hotkey = new QHotkey(seq, true); QObject::connect(hotkey, &QHotkey::activated, func);
QObject::connect(hotkey, &QHotkey::activated, func); hotkeys.insert(seqName, hotkey);
hotkeys.insert(seqName, hotkey); }
} settings::settings().setValue(seqName.prepend("hotkey_"), seq.toString());
settings::settings().setValue(seqName.prepend("hotkey_"), seq.toString());
} }
// forces the hotkey from settings // forces the hotkey from settings
void hotkeying::load(QString seqName, std::function<void()> func) { void hotkeying::load(QString seqName, std::function<void()> func) {
QHotkey *h; QHotkey *h;
QString name = seqName; QString name = seqName;
name.prepend("hotkey_"); name.prepend("hotkey_");
if (settings::settings().contains(name)) if (settings::settings().contains(name))
h = new QHotkey(QKeySequence(settings::settings().value(name).toString()), h = new QHotkey(QKeySequence(settings::settings().value(name).toString()), true);
true); else
else h = new QHotkey;
h = new QHotkey; QObject::connect(h, &QHotkey::activated, func);
QObject::connect(h, &QHotkey::activated, func); hotkeys.insert(seqName, h);
hotkeys.insert(seqName, h);
} }
bool hotkeying::valid(QString seq) { bool hotkeying::valid(QString seq) {
return seq.isEmpty() || !QKeySequence(seq).toString().isEmpty(); return seq.isEmpty() || !QKeySequence(seq).toString().isEmpty();
} }
QString hotkeying::sequence(QString seqName) { QString hotkeying::sequence(QString seqName) {
return hotkeys.contains(seqName) return hotkeys.contains(seqName) ? hotkeys.value(seqName)->shortcut().toString() : "";
? hotkeys.value(seqName)->shortcut().toString()
: "";
} }

94
io/ioutils.cpp
View File

@ -8,58 +8,56 @@ namespace ioutils {
QNetworkAccessManager networkManager; QNetworkAccessManager networkManager;
} }
void ioutils::getJson( void ioutils::getJson(QUrl target, QList<QPair<QString, QString>> headers, std::function<void(QJsonDocument, QNetworkReply *)> callback) {
QUrl target, QList<QPair<QString, QString>> headers, QNetworkRequest req(target);
std::function<void(QJsonDocument, QNetworkReply *)> callback) { for (auto header : headers) {
QNetworkRequest req(target); req.setRawHeader(header.first.toUtf8(), header.second.toUtf8());
for (auto header : headers) { }
req.setRawHeader(header.first.toUtf8(), header.second.toUtf8()); QNetworkReply *reply = networkManager.get(req);
} QObject::connect(reply, &QNetworkReply::finished, [reply, callback] {
QNetworkReply *reply = networkManager.get(req); callback(QJsonDocument::fromJson(reply->readAll()), reply);
QObject::connect(reply, &QNetworkReply::finished, [reply, callback] { reply->deleteLater();
callback(QJsonDocument::fromJson(reply->readAll()), reply); });
reply->deleteLater();
});
} }
void ioutils::postJson( void ioutils::postJson(QUrl target,
QUrl target, QList<QPair<QString, QString>> headers, QByteArray body, QList<QPair<QString, QString>> headers,
std::function<void(QJsonDocument, QNetworkReply *)> callback) { QByteArray body,
QNetworkRequest req(target); std::function<void(QJsonDocument, QNetworkReply *)> callback) {
for (auto header : headers) { QNetworkRequest req(target);
req.setRawHeader(header.first.toUtf8(), header.second.toUtf8()); for (auto header : headers) {
} req.setRawHeader(header.first.toUtf8(), header.second.toUtf8());
QNetworkReply *reply = networkManager.post(req, body); }
QObject::connect(reply, &QNetworkReply::finished, [reply, callback] { QNetworkReply *reply = networkManager.post(req, body);
callback(QJsonDocument::fromJson(reply->readAll()), reply); QObject::connect(reply, &QNetworkReply::finished, [reply, callback] {
delete reply; callback(QJsonDocument::fromJson(reply->readAll()), reply);
}); delete reply;
});
} }
void ioutils::getData( void ioutils::getData(QUrl target, QList<QPair<QString, QString>> headers, std::function<void(QByteArray, QNetworkReply *)> callback) {
QUrl target, QList<QPair<QString, QString>> headers, QNetworkRequest req(target);
std::function<void(QByteArray, QNetworkReply *)> callback) { for (auto header : headers) {
QNetworkRequest req(target); req.setRawHeader(header.first.toUtf8(), header.second.toUtf8());
for (auto header : headers) { }
req.setRawHeader(header.first.toUtf8(), header.second.toUtf8()); QNetworkReply *reply = networkManager.get(req);
} QObject::connect(reply, &QNetworkReply::finished, [reply, callback] {
QNetworkReply *reply = networkManager.get(req); callback(reply->readAll(), reply);
QObject::connect(reply, &QNetworkReply::finished, [reply, callback] { delete reply;
callback(reply->readAll(), reply); });
delete reply;
});
} }
void ioutils::postData( void ioutils::postData(QUrl target,
QUrl target, QList<QPair<QString, QString>> headers, QByteArray body, QList<QPair<QString, QString>> headers,
std::function<void(QByteArray, QNetworkReply *)> callback) { QByteArray body,
QNetworkRequest req(target); std::function<void(QByteArray, QNetworkReply *)> callback) {
for (auto header : headers) { QNetworkRequest req(target);
req.setRawHeader(header.first.toUtf8(), header.second.toUtf8()); for (auto header : headers) {
} req.setRawHeader(header.first.toUtf8(), header.second.toUtf8());
QNetworkReply *reply = networkManager.post(req, body); }
QObject::connect(reply, &QNetworkReply::finished, [reply, callback] { QNetworkReply *reply = networkManager.post(req, body);
callback(reply->readAll(), reply); QObject::connect(reply, &QNetworkReply::finished, [reply, callback] {
delete reply; callback(reply->readAll(), reply);
}); delete reply;
});
} }

14
io/ioutils.hpp
View File

@ -9,16 +9,10 @@
namespace ioutils { namespace ioutils {
extern QNetworkAccessManager networkManager; extern QNetworkAccessManager networkManager;
void getJson(QUrl target, QList<QPair<QString, QString>> headers, void getJson(QUrl target, QList<QPair<QString, QString>> headers, std::function<void(QJsonDocument, QNetworkReply *)> callback);
std::function<void(QJsonDocument, QNetworkReply *)> callback); void postJson(QUrl target, QList<QPair<QString, QString>> headers, QByteArray body, std::function<void(QJsonDocument, QNetworkReply *)> callback);
void postJson(QUrl target, QList<QPair<QString, QString>> headers, void getData(QUrl target, QList<QPair<QString, QString>> headers, std::function<void(QByteArray, QNetworkReply *)> callback);
QByteArray body, void postData(QUrl target, QList<QPair<QString, QString>> headers, QByteArray body, std::function<void(QByteArray, QNetworkReply *)> callback);
std::function<void(QJsonDocument, QNetworkReply *)> callback);
void getData(QUrl target, QList<QPair<QString, QString>> headers,
std::function<void(QByteArray, QNetworkReply *)> callback);
void postData(QUrl target, QList<QPair<QString, QString>> headers,
QByteArray body,
std::function<void(QByteArray, QNetworkReply *)> callback);
} }
#endif // IOUTILS_HPP #endif // IOUTILS_HPP

77
main.cpp
View File

@ -8,50 +8,47 @@
bool verbose = false; bool verbose = false;
void handler(QtMsgType type, const QMessageLogContext &, const QString &msg) { void handler(QtMsgType type, const QMessageLogContext &, const QString &msg) {
QByteArray localMsg = msg.toLocal8Bit(); QByteArray localMsg = msg.toLocal8Bit();
switch (type) { switch (type) {
case QtDebugMsg: case QtDebugMsg:
if (verbose) if (verbose) fprintf(stderr, "DEBUG: %s\n", localMsg.constData());
fprintf(stderr, "DEBUG: %s\n", localMsg.constData()); break;
break; case QtInfoMsg:
case QtInfoMsg: fprintf(stderr, "INFO: %s\n", localMsg.constData());
fprintf(stderr, "INFO: %s\n", localMsg.constData()); break;
break; case QtWarningMsg:
case QtWarningMsg: fprintf(stderr, "WARN: %s\n", localMsg.constData());
fprintf(stderr, "WARN: %s\n", localMsg.constData()); break;
break; case QtCriticalMsg:
case QtCriticalMsg: fprintf(stderr, "CRIT: %s\n", localMsg.constData());
fprintf(stderr, "CRIT: %s\n", localMsg.constData()); break;
break; case QtFatalMsg:
case QtFatalMsg: fprintf(stderr, "FATAL: %s\n", localMsg.constData());
fprintf(stderr, "FATAL: %s\n", localMsg.constData()); break;
break; }
}
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
qInstallMessageHandler(handler); qInstallMessageHandler(handler);
QApplication a(argc, argv); QApplication a(argc, argv);
a.setApplicationName("KShare"); a.setApplicationName("KShare");
a.setOrganizationName("ArsenArsen"); a.setOrganizationName("ArsenArsen");
a.setApplicationVersion("1.1"); a.setApplicationVersion("1.1");
QCommandLineParser parser; QCommandLineParser parser;
parser.addHelpOption(); parser.addHelpOption();
QCommandLineOption h({"b", "background"}, QCommandLineOption h({ "b", "background" }, "Does not show the main window, starts in tray.");
"Does not show the main window, starts in tray."); QCommandLineOption v({ "v", "verbose" }, "Enables QtDebugMsg outputs");
QCommandLineOption v({"v", "verbose"}, "Enables QtDebugMsg outputs"); parser.addOption(h);
parser.addOption(h); parser.addOption(v);
parser.addOption(v); parser.process(a);
parser.process(a); verbose = parser.isSet(v);
verbose = parser.isSet(v);
MainWindow w; MainWindow w;
w.show(); w.show();
QTimer::singleShot(0, [&] { QTimer::singleShot(0, [&] {
if (parser.isSet(h)) if (parser.isSet(h)) w.hide();
w.hide(); });
}); return a.exec();
return a.exec();
} }

194
mainwindow.cpp
View File

@ -20,142 +20,140 @@
MainWindow *MainWindow::instance; MainWindow *MainWindow::instance;
void addHotkeyItem(QString text, QString name, std::function<void()> *func) { void addHotkeyItem(QString text, QString name, std::function<void()> *func) {
QListWidgetItem *item = QListWidgetItem *item = new QListWidgetItem(text, MainWindow::inst()->ui->hotkeys);
new QListWidgetItem(text, MainWindow::inst()->ui->hotkeys); item->setData(Qt::UserRole + 1, name);
item->setData(Qt::UserRole + 1, name); MainWindow::inst()->fncs.insert(name, func);
MainWindow::inst()->fncs.insert(name, func); hotkeying::load(name, *func);
hotkeying::load(name, *func);
} }
MainWindow::MainWindow(QWidget *parent) MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
: QMainWindow(parent), ui(new Ui::MainWindow) { instance = this;
instance = this; ui->setupUi(this);
ui->setupUi(this); setWindowIcon(QIcon(":/icons/icon.png"));
setWindowIcon(QIcon(":/icons/icon.png")); tray = new QSystemTrayIcon(windowIcon(), this);
tray = new QSystemTrayIcon(windowIcon(), this); tray->setToolTip("KShare");
tray->setToolTip("KShare"); tray->setVisible(true);
tray->setVisible(true); QMenu *menu = new QMenu(this);
QMenu *menu = new QMenu(this); QAction *quit = new QAction("Quit", this);
QAction *quit = new QAction("Quit", this); QAction *shtoggle = new QAction("Show/Hide", this);
QAction *shtoggle = new QAction("Show/Hide", this); QAction *fullscreen = new QAction("Take fullscreen shot", this);
QAction *fullscreen = new QAction("Take fullscreen shot", this); QAction *area = new QAction("Take area shot", this);
QAction *area = new QAction("Take area shot", this); menu->addActions({ quit, shtoggle });
menu->addActions({quit, shtoggle}); menu->addSeparator();
menu->addSeparator(); menu->addActions({ fullscreen, area });
menu->addActions({fullscreen, area}); connect(quit, &QAction::triggered, this, &MainWindow::quit);
connect(quit, &QAction::triggered, this, &MainWindow::quit); connect(shtoggle, &QAction::triggered, this, &MainWindow::toggleVisible);
connect(shtoggle, &QAction::triggered, this, &MainWindow::toggleVisible); connect(tray, &QSystemTrayIcon::messageClicked, this, &MainWindow::toggleVisible);
connect(tray, &QSystemTrayIcon::messageClicked, this, connect(tray, &QSystemTrayIcon::activated, this, [this](QSystemTrayIcon::ActivationReason reason) {
&MainWindow::toggleVisible); if (reason == QSystemTrayIcon::DoubleClick) toggleVisible();
connect(tray, &QSystemTrayIcon::activated, this, });
[this](QSystemTrayIcon::ActivationReason reason) { connect(fullscreen, &QAction::triggered, this, [] { screenshotter::fullscreenDelayed(); });
if (reason == QSystemTrayIcon::DoubleClick) connect(area, &QAction::triggered, this, [] { screenshotter::areaDelayed(); });
toggleVisible(); tray->setContextMenu(menu);
});
connect(fullscreen, &QAction::triggered, this,
[] { screenshotter::fullscreenDelayed(); });
connect(area, &QAction::triggered, this,
[] { screenshotter::areaDelayed(); });
tray->setContextMenu(menu);
ui->uploaderList->setSelectionBehavior(QAbstractItemView::SelectRows); ui->uploaderList->setSelectionBehavior(QAbstractItemView::SelectRows);
ui->uploaderList->setSelectionMode(QAbstractItemView::SingleSelection); ui->uploaderList->setSelectionMode(QAbstractItemView::SingleSelection);
// Add items to uploader selection // Add items to uploader selection
for (Uploader *u : UploaderSingleton::inst().uploaderList()) for (Uploader *u : UploaderSingleton::inst().uploaderList()) newUploader(u);
newUploader(u); connect(&UploaderSingleton::inst(), &UploaderSingleton::newUploader, this, &MainWindow::newUploader);
connect(&UploaderSingleton::inst(), &UploaderSingleton::newUploader, this,
&MainWindow::newUploader);
// Set filename scheme // Set filename scheme
if ((settings::settings().contains("fileFormat"))) if ((settings::settings().contains("fileFormat")))
setScheme(settings::settings().value("fileFormat").toString()); setScheme(settings::settings().value("fileFormat").toString());
else else
setScheme("Screenshot %(yyyy-MM-dd HH:mm:ss)date"); setScheme("Screenshot %(yyyy-MM-dd HH:mm:ss)date");
auto errors = UploaderSingleton::inst().errors(); auto errors = UploaderSingleton::inst().errors();
if (errors.length() == 1) if (errors.length() == 1)
statusBar()->showMessage(errors.at(0).what()); statusBar()->showMessage(errors.at(0).what());
else else
statusBar()->showMessage( statusBar()->showMessage(QString("Errors visible in console (if present). Count: " + QString::number(errors.size())));
QString("Errors visible in console (if present). Count: " +
QString::number(errors.size())));
// Set delay // Set delay
if ((settings::settings().contains("delay"))) if ((settings::settings().contains("delay")))
ui->delay->setValue(settings::settings().value("delay").toDouble()); ui->delay->setValue(settings::settings().value("delay").toDouble());
else else
ui->delay->setValue(0.25); ui->delay->setValue(0.25);
ui->hotkeys->setSelectionMode(QListWidget::SingleSelection); ui->hotkeys->setSelectionMode(QListWidget::SingleSelection);
addHotkeyItem("Fullscreen image", "fullscreen", addHotkeyItem("Fullscreen image", "fullscreen", new std::function<void()>([] { screenshotter::fullscreen(); }));
new std::function<void()>([] { screenshotter::fullscreen(); })); addHotkeyItem("Area image", "area", new std::function<void()>([] { screenshotter::area(); }));
addHotkeyItem("Area image", "area",
new std::function<void()>([] { screenshotter::area(); }));
} }
MainWindow::~MainWindow() { delete ui; } MainWindow::~MainWindow() {
delete ui;
}
void MainWindow::setScheme(QString scheme) { ui->nameScheme->setText(scheme); } void MainWindow::setScheme(QString scheme) {
ui->nameScheme->setText(scheme);
}
QDoubleSpinBox *MainWindow::delay() { return ui->delay; } QDoubleSpinBox *MainWindow::delay() {
return ui->delay;
}
MainWindow *MainWindow::inst() { return instance; } MainWindow *MainWindow::inst() {
return instance;
}
void MainWindow::closeEvent(QCloseEvent *event) { void MainWindow::closeEvent(QCloseEvent *event) {
event->ignore(); event->ignore();
QTimer::singleShot(0, this, &MainWindow::hide); QTimer::singleShot(0, this, &MainWindow::hide);
} }
void MainWindow::quit() { QCoreApplication::quit(); } void MainWindow::quit() {
QCoreApplication::quit();
}
void MainWindow::toggleVisible() { void MainWindow::toggleVisible() {
this->setVisible(!this->isVisible()); this->setVisible(!this->isVisible());
if (this->isVisible()) { if (this->isVisible()) {
this->raise(); this->raise();
} }
} }
void MainWindow::newUploader(Uploader *u) { void MainWindow::newUploader(Uploader *u) {
QListWidgetItem *item = new QListWidgetItem(u->name()); QListWidgetItem *item = new QListWidgetItem(u->name());
item->setToolTip(u->description()); item->setToolTip(u->description());
ui->uploaderList->addItem(item); ui->uploaderList->addItem(item);
if (u->name() == UploaderSingleton::inst().selectedUploader()) if (u->name() == UploaderSingleton::inst().selectedUploader()) item->setSelected(true);
item->setSelected(true);
} }
void MainWindow::on_actionQuit_triggered() { quit(); } void MainWindow::on_actionQuit_triggered() {
quit();
}
void MainWindow::on_actionFullscreen_triggered() { void MainWindow::on_actionFullscreen_triggered() {
screenshotter::fullscreenDelayed(); screenshotter::fullscreenDelayed();
} }
void MainWindow::on_actionArea_triggered() { screenshotter::areaDelayed(); } void MainWindow::on_actionArea_triggered() {
screenshotter::areaDelayed();
}
void MainWindow::on_uploaderList_clicked(const QModelIndex &) { void MainWindow::on_uploaderList_clicked(const QModelIndex &) {
QList<QListWidgetItem *> index = ui->uploaderList->selectedItems(); QList<QListWidgetItem *> index = ui->uploaderList->selectedItems();
if (index.size() == 1) { if (index.size() == 1) {
UploaderSingleton::inst().set(index.at(0)->text()); UploaderSingleton::inst().set(index.at(0)->text());
} }
} }
void MainWindow::on_nameScheme_textEdited(const QString &arg1) { void MainWindow::on_nameScheme_textEdited(const QString &arg1) {
settings::settings().setValue("fileFormat", arg1); settings::settings().setValue("fileFormat", arg1);
} }
void MainWindow::on_delay_valueChanged(double arg1) { void MainWindow::on_delay_valueChanged(double arg1) {
settings::settings().setValue("delay", arg1); settings::settings().setValue("delay", arg1);
} }
void MainWindow::on_hotkeys_doubleClicked(const QModelIndex &) { void MainWindow::on_hotkeys_doubleClicked(const QModelIndex &) {
if (ui->hotkeys->selectedItems().length() == 1) { if (ui->hotkeys->selectedItems().length() == 1) {
QListWidgetItem *i = ui->hotkeys->selectedItems().at(0); QListWidgetItem *i = ui->hotkeys->selectedItems().at(0);
QString str = i->data(Qt::UserRole + 1).toString(); QString str = i->data(Qt::UserRole + 1).toString();
QString seq = QInputDialog::getText(ui->centralWidget, "Hotkey Input", QString seq = QInputDialog::getText(ui->centralWidget, "Hotkey Input", "Insert hotkey:", QLineEdit::Normal,
"Insert hotkey:", QLineEdit::Normal, hotkeying::sequence(str));
hotkeying::sequence(str)); if (hotkeying::valid(seq)) hotkeying::hotkey(str, QKeySequence(seq), *fncs.value(str));
if (hotkeying::valid(seq)) }
hotkeying::hotkey(str, QKeySequence(seq), *fncs.value(str));
}
} }

50
mainwindow.hpp
View File

@ -14,39 +14,39 @@ class MainWindow;
} }
class MainWindow : public QMainWindow { class MainWindow : public QMainWindow {
Q_OBJECT Q_OBJECT
private slots: private slots:
void quit(); void quit();
void toggleVisible(); void toggleVisible();
void newUploader(Uploader *u); void newUploader(Uploader *u);
void on_actionQuit_triggered(); void on_actionQuit_triggered();
void on_actionFullscreen_triggered(); void on_actionFullscreen_triggered();
void on_actionArea_triggered(); void on_actionArea_triggered();
void on_uploaderList_clicked(const QModelIndex &); void on_uploaderList_clicked(const QModelIndex &);
void on_nameScheme_textEdited(const QString &arg1); void on_nameScheme_textEdited(const QString &arg1);
void on_delay_valueChanged(double arg1); void on_delay_valueChanged(double arg1);
void on_hotkeys_doubleClicked(const QModelIndex &index); void on_hotkeys_doubleClicked(const QModelIndex &index);
public: public:
explicit MainWindow(QWidget *parent = 0); explicit MainWindow(QWidget *parent = 0);
~MainWindow(); ~MainWindow();
Ui::MainWindow *ui; Ui::MainWindow *ui;
QSystemTrayIcon *tray; QSystemTrayIcon *tray;
void setScheme(QString scheme); void setScheme(QString scheme);
QDoubleSpinBox *delay(); QDoubleSpinBox *delay();
static MainWindow *inst(); static MainWindow *inst();
QMap<QString, std::function<void()> *> fncs; QMap<QString, std::function<void()> *> fncs;
private: private:
static MainWindow *instance; static MainWindow *instance;
protected: protected:
void closeEvent(QCloseEvent *event); void closeEvent(QCloseEvent *event);
}; };
#endif // MAINWINDOW_HPP #endif // MAINWINDOW_HPP

7
notifications.cpp
View File

@ -3,8 +3,7 @@
#include "mainwindow.hpp" #include "mainwindow.hpp"
#include <QStatusBar> #include <QStatusBar>
void notifications::notify(QString title, QString body, void notifications::notify(QString title, QString body, QSystemTrayIcon::MessageIcon icon) {
QSystemTrayIcon::MessageIcon icon) { MainWindow::inst()->tray->showMessage(title, body, icon, 5000);
MainWindow::inst()->tray->showMessage(title, body, icon, 5000); MainWindow::inst()->statusBar()->showMessage(title + ": " + body);
MainWindow::inst()->statusBar()->showMessage(title + ": " + body);
} }

3
notifications.hpp
View File

@ -5,8 +5,7 @@
#include <QSystemTrayIcon> #include <QSystemTrayIcon>
namespace notifications { namespace notifications {
void notify(QString title, QString body, void notify(QString title, QString body, QSystemTrayIcon::MessageIcon icon = QSystemTrayIcon::Information);
QSystemTrayIcon::MessageIcon icon = QSystemTrayIcon::Information);
} }
#endif // NOTIFICATIONS_HPP #endif // NOTIFICATIONS_HPP

14
screenshotter.cpp
View File

@ -7,22 +7,18 @@
#include <QTimer> #include <QTimer>
void screenshotter::area() { void screenshotter::area() {
CropEditor *editor = new CropEditor(screenshotutil::fullscreen()); CropEditor *editor = new CropEditor(screenshotutil::fullscreen());
QObject::connect(editor, &CropEditor::cropped, [&](QPixmap *pixmap) { QObject::connect(editor, &CropEditor::cropped, [&](QPixmap *pixmap) { UploaderSingleton::inst().upload(pixmap); });
UploaderSingleton::inst().upload(pixmap);
});
} }
void screenshotter::fullscreen() { void screenshotter::fullscreen() {
UploaderSingleton::inst().upload(screenshotutil::fullscreen()); UploaderSingleton::inst().upload(screenshotutil::fullscreen());
} }
void screenshotter::areaDelayed() { void screenshotter::areaDelayed() {
QTimer::singleShot(MainWindow::inst()->delay()->value() * 1000, QTimer::singleShot(MainWindow::inst()->delay()->value() * 1000, &screenshotter::area);
&screenshotter::area);
} }
void screenshotter::fullscreenDelayed() { void screenshotter::fullscreenDelayed() {
QTimer::singleShot(MainWindow::inst()->delay()->value() * 1000, QTimer::singleShot(MainWindow::inst()->delay()->value() * 1000, &screenshotter::fullscreen);
&screenshotter::fullscreen);
} }

16
screenshotutil.cpp
View File

@ -5,16 +5,18 @@
#include <QPixmap> #include <QPixmap>
#include <QScreen> #include <QScreen>
QPixmap *screenshotutil::fullscreen() { return window(0); } QPixmap *screenshotutil::fullscreen() {
return window(0);
}
QPixmap *screenshotutil::window(long wid) { QPixmap *screenshotutil::window(long wid) {
QScreen *w = QApplication::primaryScreen(); QScreen *w = QApplication::primaryScreen();
QPixmap screen = w->grabWindow(wid); QPixmap screen = w->grabWindow(wid);
QPixmap *pm = new QPixmap(screen.size()); QPixmap *pm = new QPixmap(screen.size());
screen.swap(*pm); screen.swap(*pm);
return pm; return pm;
} }
void screenshotutil::toClipboard(QString value) { void screenshotutil::toClipboard(QString value) {
QApplication::clipboard()->setText(value); QApplication::clipboard()->setText(value);
} }

17
settings.cpp
View File

@ -3,14 +3,11 @@
#include <QStandardPaths> #include <QStandardPaths>
QSettings &settings::settings() { QSettings &settings::settings() {
static QDir configDir( static QDir configDir(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation));
QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation)); if (configDir.path() == QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation)) {
if (configDir.path() == configDir.mkdir("KShare");
QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation)) { configDir.cd("KShare");
configDir.mkdir("KShare"); }
configDir.cd("KShare"); static QSettings settings(configDir.absoluteFilePath("settings.ini"), QSettings::IniFormat);
} return settings;
static QSettings settings(configDir.absoluteFilePath("settings.ini"),
QSettings::IniFormat);
return settings;
} }

512
uploaders/customuploader.cpp
View File

@ -13,316 +13,280 @@
using std::runtime_error; using std::runtime_error;
void error(QString absFilePath, QString err) { void error(QString absFilePath, QString err) {
throw runtime_error( throw runtime_error((QString("Invalid file: ").append(absFilePath) + ": " + err).toStdString());
(QString("Invalid file: ").append(absFilePath) + ": " + err)
.toStdString());
} }
CustomUploader::CustomUploader(QString absFilePath) { CustomUploader::CustomUploader(QString absFilePath) {
types.insert("PNG", "image/png"); // This is a list of supported formats, too types.insert("PNG", "image/png"); // This is a list of supported formats, too
types.insert("GIF", "image/gif"); types.insert("GIF", "image/gif");
types.insert("JPG", "image/jpeg"); types.insert("JPG", "image/jpeg");
types.insert("JPEG", "image/jpeg"); types.insert("JPEG", "image/jpeg");
types.insert("WEBM", "video/webm"); types.insert("WEBM", "video/webm");
types.insert("MP4", "video/mp4"); types.insert("MP4", "video/mp4");
// Let's go // Let's go
QFile file(absFilePath); QFile file(absFilePath);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) error(absFilePath, file.errorString());
error(absFilePath, file.errorString()); QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
QJsonDocument doc = QJsonDocument::fromJson(file.readAll()); if (!doc.isObject()) {
if (!doc.isObject()) { error(absFilePath, "Root not an object");
error(absFilePath, "Root not an object");
}
QJsonObject obj = doc.object();
if (!obj["name"].isString())
error(absFilePath, "name is not a string");
else
uName = obj["name"].toString();
if (!obj.contains("desc")) {
if (!obj["desc"].isString())
/*t*/ error(absFilePath, "desc not a string");
else
desc = obj["desc"].toString();
} else
desc = absFilePath;
QJsonValue m = obj["method"];
if (!m.isUndefined() && !m.isNull()) {
if (!m.isString())
error(absFilePath, "method not a string");
QString toCheck = m.toString().toLower();
if (toCheck == "post")
method = HttpMethod::POST;
else
error(absFilePath, "method invalid");
}
QJsonValue url = obj["target"];
if (!url.isString()) {
error(absFilePath, "target missing");
}
QUrl target(url.toString());
if (!target.isValid())
error(absFilePath, "target not URL");
this->target = target;
QJsonValue formatValue = obj["format"];
if (!formatValue.isUndefined() && !formatValue.isNull()) {
if (formatValue.isString()) {
QString formatString = formatValue.toString().toLower();
if (formatString == "x-www-form-urlencoded")
format = RequestFormat::X_WWW_FORM_URLENCODED;
else if (formatString == "json")
format = RequestFormat::JSON;
else if (formatString == "plain")
format = RequestFormat::PLAIN;
else
error(absFilePath, "format invalid");
} }
} else QJsonObject obj = doc.object();
error(absFilePath, "format provided but not string"); if (!obj["name"].isString())
QJsonValue imageValue = obj["imageformat"]; error(absFilePath, "name is not a string");
if (!imageValue.isString()) {
error(absFilePath, "imageformat not string");
}
QString imageFormat = imageValue.toString();
if (imageFormat == "base64" ||
QRegExp("base64\\([^+]+\\+[^+]+)").exactMatch(imageFormat) ||
QRegExp("[^+]+\\+[^+]+").exactMatch(imageFormat)) {
this->iFormat = imageFormat;
} else
error(absFilePath, "imageformat invalid");
QJsonValue bodyValue = obj["body"];
if (format != RequestFormat::PLAIN) {
if (bodyValue.isUndefined())
error(absFilePath, "body not set");
if (bodyValue.isObject())
body = bodyValue;
else else
error(absFilePath, "body not object"); uName = obj["name"].toString();
} else { if (!obj.contains("desc")) {
if (bodyValue.isString()) { if (!obj["desc"].isString())
body = bodyValue; /*t*/ error(absFilePath, "desc not a string");
else
desc = obj["desc"].toString();
} else } else
error(absFilePath, "body not string (reason: format: PLAIN)"); desc = absFilePath;
} QJsonValue m = obj["method"];
QJsonValue headerVal = obj["headers"]; if (!m.isUndefined() && !m.isNull()) {
if (!(headerVal.isUndefined() || headerVal.isNull())) { if (!m.isString()) error(absFilePath, "method not a string");
if (!headerVal.isObject()) QString toCheck = m.toString().toLower();
error(absFilePath, "headers must be object"); if (toCheck == "post")
headers = headerVal.toObject(); method = HttpMethod::POST;
} else else
headers = QJsonObject(); error(absFilePath, "method invalid");
QJsonValue returnPsVal = obj["return"]; }
if (returnPsVal.isString()) { QJsonValue url = obj["target"];
returnPathspec = returnPsVal.toString(); if (!url.isString()) {
} else error(absFilePath, "target missing");
error(absFilePath, "return invalid"); }
QUrl target(url.toString());
if (!target.isValid()) error(absFilePath, "target not URL");
this->target = target;
QJsonValue formatValue = obj["format"];
if (!formatValue.isUndefined() && !formatValue.isNull()) {
if (formatValue.isString()) {
QString formatString = formatValue.toString().toLower();
if (formatString == "x-www-form-urlencoded")
format = RequestFormat::X_WWW_FORM_URLENCODED;
else if (formatString == "json")
format = RequestFormat::JSON;
else if (formatString == "plain")
format = RequestFormat::PLAIN;
else
error(absFilePath, "format invalid");
}
} else
error(absFilePath, "format provided but not string");
QJsonValue imageValue = obj["imageformat"];
if (!imageValue.isString()) {
error(absFilePath, "imageformat not string");
}
QString imageFormat = imageValue.toString();
if (imageFormat == "base64" || QRegExp("base64\\([^+]+\\+[^+]+)").exactMatch(imageFormat)
|| QRegExp("[^+]+\\+[^+]+").exactMatch(imageFormat)) {
this->iFormat = imageFormat;
} else
error(absFilePath, "imageformat invalid");
QJsonValue bodyValue = obj["body"];
if (format != RequestFormat::PLAIN) {
if (bodyValue.isUndefined()) error(absFilePath, "body not set");
if (bodyValue.isObject())
body = bodyValue;
else
error(absFilePath, "body not object");
} else {
if (bodyValue.isString()) {
body = bodyValue;
} else
error(absFilePath, "body not string (reason: format: PLAIN)");
}
QJsonValue headerVal = obj["headers"];
if (!(headerVal.isUndefined() || headerVal.isNull())) {
if (!headerVal.isObject()) error(absFilePath, "headers must be object");
headers = headerVal.toObject();
} else
headers = QJsonObject();
QJsonValue returnPsVal = obj["return"];
if (returnPsVal.isString()) {
returnPathspec = returnPsVal.toString();
} else
error(absFilePath, "return invalid");
} }
QString CustomUploader::name() { return uName; } QString CustomUploader::name() {
return uName;
}
QString CustomUploader::description() { return desc; } QString CustomUploader::description() {
return desc;
}
QString getCType(RequestFormat format, QString plainType) { QString getCType(RequestFormat format, QString plainType) {
switch (format) { switch (format) {
case RequestFormat::X_WWW_FORM_URLENCODED: case RequestFormat::X_WWW_FORM_URLENCODED:
return "application/x-www-form-urlencoded"; return "application/x-www-form-urlencoded";
case RequestFormat::JSON: case RequestFormat::JSON:
return "application/json"; return "application/json";
case RequestFormat::PLAIN: case RequestFormat::PLAIN:
return plainType;
}
return plainType; return plainType;
}
return plainType;
} }
QList<QPair<QString, QString>> getHeaders(QJsonObject h, QString imageFormat, QList<QPair<QString, QString>> getHeaders(QJsonObject h, QString imageFormat, QMap<QString, QString> types, RequestFormat format) {
QMap<QString, QString> types, QList<QPair<QString, QString>> headers;
RequestFormat format) { for (QString s : h.keys()) {
QList<QPair<QString, QString>> headers; if (s.toLower() == "content-type") continue;
for (QString s : h.keys()) { QJsonValue v = h[s];
if (s.toLower() == "content-type") if (!v.isString())
continue; headers << QPair<QString, QString>(s, QJsonDocument::fromVariant(v.toVariant()).toJson());
QJsonValue v = h[s]; else
if (!v.isString()) headers << QPair<QString, QString>(s, v.toString());
headers << QPair<QString, QString>( }
s, QJsonDocument::fromVariant(v.toVariant()).toJson()); headers << QPair<QString, QString>("Content-Type", getCType(format, types.value(imageFormat)));
else return headers;
headers << QPair<QString, QString>(s, v.toString());
}
headers << QPair<QString, QString>(
"Content-Type", getCType(format, types.value(imageFormat)));
return headers;
} }
QByteArray imageBytes(QPixmap *pixmap, QString format) { QByteArray imageBytes(QPixmap *pixmap, QString format) {
QByteArray returnVal; QByteArray returnVal;
QBuffer buff(&returnVal); QBuffer buff(&returnVal);
buff.open(QIODevice::WriteOnly); buff.open(QIODevice::WriteOnly);
pixmap->save(&buff, format.toUpper().toLocal8Bit().constData()); pixmap->save(&buff, format.toUpper().toLocal8Bit().constData());
return returnVal; return returnVal;
} }
QString CustomUploader::getFormatString(bool animated) { QString CustomUploader::getFormatString(bool animated) {
if (iFormat == "base64") if (iFormat == "base64")
return animated ? "GIF" : "PNG"; return animated ? "GIF" : "PNG";
else if (QRegExp("[^+]+\\+[^+]+").exactMatch(iFormat)) else if (QRegExp("[^+]+\\+[^+]+").exactMatch(iFormat))
return iFormat.split('+')[(int)animated]; return iFormat.split('+')[(int)animated];
else if (QRegExp("base64\\([^+]+\\+[^+]+)").exactMatch(iFormat)) else if (QRegExp("base64\\([^+]+\\+[^+]+)").exactMatch(iFormat))
return iFormat.mid(7, iFormat.length() - 8).split('+')[(int)animated]; return iFormat.mid(7, iFormat.length() - 8).split('+')[(int)animated];
return ""; return "";
} }
QJsonObject recurseAndReplace(QJsonObject &body, QByteArray &data, QJsonObject recurseAndReplace(QJsonObject &body, QByteArray &data, QString contentType) {
QString contentType) { QJsonObject o;
QJsonObject o; for (QString s : body.keys()) {
for (QString s : body.keys()) { QJsonValue v = body[s];
QJsonValue v = body[s]; if (v.isObject()) {
if (v.isObject()) { QJsonObject vo = v.toObject();
QJsonObject vo = v.toObject(); o.insert(s, recurseAndReplace(vo, data, contentType));
o.insert(s, recurseAndReplace(vo, data, contentType)); } else if (v.isString()) {
} else if (v.isString()) { QString str = v.toString();
QString str = v.toString(); if (str.startsWith("/") && str.endsWith("/")) {
if (str.startsWith("/") && str.endsWith("/")) { o.insert(s, str.replace("%image", data).replace("%contenttype", contentType));
o.insert( }
s, }
str.replace("%image", data).replace("%contenttype", contentType));
}
} }
} return o;
return o;
} }
QString parsePathspec(QJsonDocument &response, QString &pathspec) { QString parsePathspec(QJsonDocument &response, QString &pathspec) {
if (!pathspec.startsWith(".")) { if (!pathspec.startsWith(".")) {
// Does not point to anything // Does not point to anything
return "";
} else {
if (!response.isObject())
return "";
QStringList fields = pathspec.right(pathspec.length() - 1)
.split('.', QString::SkipEmptyParts);
QJsonObject o = response.object();
if (pathspec == ".") {
return QString::fromUtf8(response.toJson());
}
QJsonValue val = o[fields.at(0)];
if (val.isUndefined() || val.isNull())
return "";
else if (val.isString())
return val.toString();
else if (!val.isObject())
return QString::fromUtf8(
QJsonDocument::fromVariant(val.toVariant()).toJson());
for (int i = 1; i < fields.size(); i++) {
if (val.isUndefined() || val.isNull())
return ""; return "";
else if (val.isString()) } else {
return val.toString(); if (!response.isObject()) return "";
else if (!val.isObject()) QStringList fields = pathspec.right(pathspec.length() - 1).split('.', QString::SkipEmptyParts);
return QString::fromUtf8( QJsonObject o = response.object();
QJsonDocument::fromVariant(val.toVariant()).toJson()); if (pathspec == ".") {
else return QString::fromUtf8(response.toJson());
val = val.toObject()[fields.at(i)]; }
QJsonValue val = o[fields.at(0)];
if (val.isUndefined() || val.isNull())
return "";
else if (val.isString())
return val.toString();
else if (!val.isObject())
return QString::fromUtf8(QJsonDocument::fromVariant(val.toVariant()).toJson());
for (int i = 1; i < fields.size(); i++) {
if (val.isUndefined() || val.isNull())
return "";
else if (val.isString())
return val.toString();
else if (!val.isObject())
return QString::fromUtf8(QJsonDocument::fromVariant(val.toVariant()).toJson());
else
val = val.toObject()[fields.at(i)];
}
if (val.isUndefined() || val.isNull())
return "";
else if (val.isString())
return val.toString();
else if (!val.isObject())
return QString::fromUtf8(QJsonDocument::fromVariant(val.toVariant()).toJson());
} }
if (val.isUndefined() || val.isNull()) return "";
return "";
else if (val.isString())
return val.toString();
else if (!val.isObject())
return QString::fromUtf8(
QJsonDocument::fromVariant(val.toVariant()).toJson());
}
return "";
} }
void parseResult(QJsonDocument result, QString returnPathspec, QString name) { void parseResult(QJsonDocument result, QString returnPathspec, QString name) {
if (result.isObject()) { if (result.isObject()) {
qDebug() << result.object()[".url"]; qDebug() << result.object()[".url"];
QString url = parsePathspec(result, returnPathspec); QString url = parsePathspec(result, returnPathspec);
if (!url.isEmpty()) { if (!url.isEmpty()) {
QApplication::clipboard()->setText(url); QApplication::clipboard()->setText(url);
notifications::notify("KShare Custom Uploader " + name, notifications::notify("KShare Custom Uploader " + name, "Copied upload link to clipboard!");
"Copied upload link to clipboard!"); } else
notifications::notify("KShare Custom Uploader " + name, "Upload done, but result empty!");
} else } else
notifications::notify("KShare Custom Uploader " + name, notifications::notify("KShare Custom Uploader " + name, "Upload done, but result is not JSON Object!");
"Upload done, but result empty!");
} else
notifications::notify("KShare Custom Uploader " + name,
"Upload done, but result is not JSON Object!");
} }
void CustomUploader::doUpload(QPixmap *pixmap) { void CustomUploader::doUpload(QPixmap *pixmap) {
auto h = getHeaders(headers, getFormatString(false), types, this->format); auto h = getHeaders(headers, getFormatString(false), types, this->format);
QString format = getFormatString(false); // Soon:tm: QString format = getFormatString(false); // Soon:tm:
QByteArray data; QByteArray data;
QByteArray imgData = imageBytes(pixmap, format); QByteArray imgData = imageBytes(pixmap, format);
if (iFormat == "base64" || if (iFormat == "base64" || QRegExp("base64\\([^+]\\+[^+]\\)").exactMatch(iFormat)) imgData = imgData.toBase64();
QRegExp("base64\\([^+]\\+[^+]\\)").exactMatch(iFormat)) switch (this->format) {
imgData = imgData.toBase64(); case RequestFormat::PLAIN: {
switch (this->format) { data = imgData;
case RequestFormat::PLAIN: { } break;
data = imgData; case RequestFormat::JSON: {
} break; if (body.isString()) {
case RequestFormat::JSON: { QStringList split = body.toString().replace("%contenttype", types.value(format)).split("%imagedata");
if (body.isString()) { for (int i = 0; i < split.size(); i++) {
QStringList split = body.toString() data.append(split[i]);
.replace("%contenttype", types.value(format)) if (i < split.size() - 1) data.append(imgData);
.split("%imagedata"); }
for (int i = 0; i < split.size(); i++) { } else {
data.append(split[i]); QJsonObject vo = body.toObject();
if (i < split.size() - 1) data = QJsonDocument::fromVariant(recurseAndReplace(vo, imgData, types.value(format)).toVariantMap()).toJson();
data.append(imgData);
}
} else {
QJsonObject vo = body.toObject();
data = QJsonDocument::fromVariant(
recurseAndReplace(vo, imgData, types.value(format))
.toVariantMap())
.toJson();
}
} break;
case RequestFormat::X_WWW_FORM_URLENCODED: {
QJsonObject body = this->body.toObject();
for (QString key : body.keys()) {
QJsonValue val = body[key];
if (val.isString()) {
QString str = val.toString();
QByteArray strB;
if (str.startsWith("/") && str.endsWith("/")) {
str = str.mid(1, str.length() - 2);
QStringList split = str.replace("%contenttype", types.value(format))
.split("%imagedata");
for (int i = 0; i < split.size(); i++) {
strB.append(split[i]);
if (i < split.size() - 1)
strB.append(imgData);
}
} }
data.append(QUrl::toPercentEncoding(key)).append('=').append(strB); } break;
} else { case RequestFormat::X_WWW_FORM_URLENCODED: {
if (!data.isEmpty()) QJsonObject body = this->body.toObject();
data.append('&'); for (QString key : body.keys()) {
data.append(QUrl::toPercentEncoding(key)) QJsonValue val = body[key];
.append('=') if (val.isString()) {
.append(QUrl::toPercentEncoding( QString str = val.toString();
QJsonDocument::fromVariant(body[key].toVariant()).toJson())); QByteArray strB;
} if (str.startsWith("/") && str.endsWith("/")) {
str = str.mid(1, str.length() - 2);
QStringList split = str.replace("%contenttype", types.value(format)).split("%imagedata");
for (int i = 0; i < split.size(); i++) {
strB.append(split[i]);
if (i < split.size() - 1) strB.append(imgData);
}
}
data.append(QUrl::toPercentEncoding(key)).append('=').append(strB);
} else {
if (!data.isEmpty()) data.append('&');
data.append(QUrl::toPercentEncoding(key))
.append('=')
.append(QUrl::toPercentEncoding(QJsonDocument::fromVariant(body[key].toVariant()).toJson()));
}
}
} break;
} }
} break; switch (method) {
} case HttpMethod::POST:
switch (method) { if (returnPathspec == "|") {
case HttpMethod::POST: ioutils::postData(target, h, data, [&](QByteArray result, QNetworkReply *) {
if (returnPathspec == "|") { QApplication::clipboard()->setText(QString::fromUtf8(result));
ioutils::postData( notifications::notify("KShare Custom Uploader " + name(), "Copied upload result to clipboard!");
target, h, data, [&](QByteArray result, QNetworkReply *) { });
QApplication::clipboard()->setText(QString::fromUtf8(result)); } else {
notifications::notify("KShare Custom Uploader " + name(), ioutils::postJson(target, h, data,
"Copied upload result to clipboard!"); [&](QJsonDocument result, QNetworkReply *) { parseResult(result, returnPathspec, name()); });
}); }
} else { break;
ioutils::postJson(target, h, data,
[&](QJsonDocument result, QNetworkReply *) {
parseResult(result, returnPathspec, name());
});
} }
break;
}
} }

34
uploaders/customuploader.hpp
View File

@ -11,24 +11,24 @@ enum class HttpMethod { POST };
enum class RequestFormat { X_WWW_FORM_URLENCODED, JSON, PLAIN }; enum class RequestFormat { X_WWW_FORM_URLENCODED, JSON, PLAIN };
class CustomUploader : public Uploader { class CustomUploader : public Uploader {
public: public:
CustomUploader(QString absFilePath); CustomUploader(QString absFilePath);
QString name(); QString name();
QString description(); QString description();
void doUpload(QPixmap *pixmap); void doUpload(QPixmap *pixmap);
QString getFormatString(bool animated); QString getFormatString(bool animated);
QMap<QString, QString> types; QMap<QString, QString> types;
private: private:
QString desc; QString desc;
QString uName; QString uName;
RequestFormat format = RequestFormat::JSON; RequestFormat format = RequestFormat::JSON;
HttpMethod method = HttpMethod::POST; HttpMethod method = HttpMethod::POST;
QUrl target; QUrl target;
QJsonValue body; QJsonValue body;
QJsonObject headers; QJsonObject headers;
QString returnPathspec; QString returnPathspec;
QString iFormat; QString iFormat;
}; };
#endif // CUSTOMUPLOADER_HPP #endif // CUSTOMUPLOADER_HPP

4
uploaders/default/clipboarduploader.cpp
View File

@ -5,6 +5,6 @@
#include <notifications.hpp> #include <notifications.hpp>
void ClipboardUploader::doUpload(QPixmap *pixmap) { void ClipboardUploader::doUpload(QPixmap *pixmap) {
QApplication::clipboard()->setImage(pixmap->toImage()); QApplication::clipboard()->setImage(pixmap->toImage());
notifications::notify("KShare", "Copied to clipboard!"); notifications::notify("KShare", "Copied to clipboard!");
} }

12
uploaders/default/clipboarduploader.hpp
View File

@ -5,10 +5,14 @@
#include <uploaders/uploader.hpp> #include <uploaders/uploader.hpp>
class ClipboardUploader : public Uploader { class ClipboardUploader : public Uploader {
public: public:
QString name() { return "clipboard"; } QString name() {
QString description() { return "Copies the image to clipboard"; } return "clipboard";
void doUpload(QPixmap *pixmap); }
QString description() {
return "Copies the image to clipboard";
}
void doUpload(QPixmap *pixmap);
}; };
#endif // CLIPBOARDUPLOADER_HPP #endif // CLIPBOARDUPLOADER_HPP

31
uploaders/default/imguruploader.cpp
View File

@ -8,22 +8,17 @@
#include <screenshotutil.hpp> #include <screenshotutil.hpp>
void ImgurUploader::doUpload(QPixmap *pixmap) { void ImgurUploader::doUpload(QPixmap *pixmap) {
QByteArray byteArray; QByteArray byteArray;
QBuffer buffer(&byteArray); QBuffer buffer(&byteArray);
pixmap->save(&buffer, "PNG"); pixmap->save(&buffer, "PNG");
ioutils::postJson( ioutils::postJson(QUrl("https://api.imgur.com/3/image"),
QUrl("https://api.imgur.com/3/image"), QList<QPair<QString, QString>>()
QList<QPair<QString, QString>>() << QPair<QString, QString>("Content-Type", "application/x-www-form-urlencoded")
<< QPair<QString, QString>("Content-Type", << QPair<QString, QString>("Authorization", "Client-ID 8a98f183fc895da"),
"application/x-www-form-urlencoded") byteArray, [](QJsonDocument res, QNetworkReply *) {
<< QPair<QString, QString>("Authorization", QString result = res.object()["data"].toObject()["link"].toString();
"Client-ID 8a98f183fc895da"), screenshotutil::toClipboard(result);
byteArray, [](QJsonDocument res, QNetworkReply *) { notifications::notify("KShare imgur Uploader ",
QString result = res.object()["data"].toObject()["link"].toString(); result.isEmpty() ? "Failed upload!" : "Upload done, but result empty!");
screenshotutil::toClipboard(result); });
notifications::notify("KShare imgur Uploader ",
result.isEmpty()
? "Failed upload!"
: "Upload done, but result empty!");
});
} }

12
uploaders/default/imguruploader.hpp
View File

@ -4,10 +4,14 @@
#include "../uploader.hpp" #include "../uploader.hpp"
class ImgurUploader : public Uploader { class ImgurUploader : public Uploader {
public: public:
QString name() { return "imgur"; } QString name() {
QString description() { return "imgur.com uploader"; } return "imgur";
void doUpload(QPixmap *pixmap); }
QString description() {
return "imgur.com uploader";
}
void doUpload(QPixmap *pixmap);
}; };
#endif // IMGURUPLOADER_HPP #endif // IMGURUPLOADER_HPP

8
uploaders/uploader.hpp
View File

@ -5,10 +5,10 @@
#include <QString> #include <QString>
class Uploader { class Uploader {
public: public:
virtual void doUpload(QPixmap *pixmap) = 0; virtual void doUpload(QPixmap *pixmap) = 0;
virtual QString name() = 0; virtual QString name() = 0;
virtual QString description() = 0; virtual QString description() = 0;
}; };
#endif // UPLOADER_HPP #endif // UPLOADER_HPP

94
uploaders/uploadersingleton.cpp
View File

@ -9,69 +9,69 @@
#include <settings.hpp> #include <settings.hpp>
UploaderSingleton::UploaderSingleton() : QObject() { UploaderSingleton::UploaderSingleton() : QObject() {
QDir configDir( QDir configDir(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation));
QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation)); configDir.mkpath("KShare/uploaders");
configDir.mkpath("KShare/uploaders"); configDir.cd("KShare/uploaders");
configDir.cd("KShare/uploaders"); configDir.setNameFilters({ "*.uploader" });
configDir.setNameFilters({"*.uploader"}); for (QString file : configDir.entryList()) {
for (QString file : configDir.entryList()) { try {
try { registerUploader(new CustomUploader(configDir.absoluteFilePath(file)));
registerUploader(new CustomUploader(configDir.absoluteFilePath(file))); } catch (std::runtime_error e) {
} catch (std::runtime_error e) { qWarning() << e.what();
qWarning() << e.what(); errs << e;
errs << e; }
} }
}
// UPLOADERS // UPLOADERS
registerUploader(new ImgurUploader); registerUploader(new ImgurUploader);
registerUploader(new ClipboardUploader); registerUploader(new ClipboardUploader);
// --------- // ---------
if (settings::settings().contains("uploader")) if (settings::settings().contains("uploader"))
uploader = settings::settings().value("uploader").toString(); uploader = settings::settings().value("uploader").toString();
else else
settings::settings().setValue("uploader", uploader); settings::settings().setValue("uploader", uploader);
if (!uploaders.contains(uploader)) { if (!uploaders.contains(uploader)) {
settings::settings().setValue("uploader", uploader); settings::settings().setValue("uploader", uploader);
uploader = "imgur"; uploader = "imgur";
} }
} }
void UploaderSingleton::registerUploader(Uploader *uploader) { void UploaderSingleton::registerUploader(Uploader *uploader) {
if (uploaders.contains(uploader->name())) { if (uploaders.contains(uploader->name())) {
throw std::runtime_error( throw std::runtime_error(("Ambigious uploader " + uploader->name()).toStdString());
("Ambigious uploader " + uploader->name()).toStdString()); }
} uploaders.insert(uploader->name(), uploader);
uploaders.insert(uploader->name(), uploader); emit newUploader(uploader);
emit newUploader(uploader);
} }
void UploaderSingleton::upload(QPixmap *pixmap) { void UploaderSingleton::upload(QPixmap *pixmap) {
if (settings::settings().contains("fileFormat")) { if (settings::settings().contains("fileFormat")) {
QString format = settings::settings().value("fileFormat").toString(); QString format = settings::settings().value("fileFormat").toString();
if (!format.isEmpty()) { if (!format.isEmpty()) {
pixmap->save(QDir(QStandardPaths::writableLocation( pixmap->save(QDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation)).absoluteFilePath(formatter::format(format) + ".png"),
QStandardPaths::PicturesLocation)) "PNG");
.absoluteFilePath(formatter::format(format) + ".png"), }
"PNG");
} }
} uploaders.value(uploader)->doUpload(pixmap);
uploaders.value(uploader)->doUpload(pixmap); delete pixmap;
delete pixmap;
} }
QList<Uploader *> UploaderSingleton::uploaderList() { QList<Uploader *> UploaderSingleton::uploaderList() {
return uploaders.values(); return uploaders.values();
} }
void UploaderSingleton::set(QString uploader) { void UploaderSingleton::set(QString uploader) {
if (uploaders.contains(uploader)) { if (uploaders.contains(uploader)) {
this->uploader = uploader; this->uploader = uploader;
settings::settings().setValue("uploader", uploader); settings::settings().setValue("uploader", uploader);
} }
} }
QString UploaderSingleton::selectedUploader() { return uploader; } QString UploaderSingleton::selectedUploader() {
return uploader;
}
QList<std::runtime_error> UploaderSingleton::errors() { return errs; } QList<std::runtime_error> UploaderSingleton::errors() {
return errs;
}

38
uploaders/uploadersingleton.hpp
View File

@ -5,26 +5,26 @@
#include <QMap> #include <QMap>
class UploaderSingleton : public QObject { class UploaderSingleton : public QObject {
Q_OBJECT Q_OBJECT
public: public:
static UploaderSingleton &inst() { static UploaderSingleton &inst() {
static UploaderSingleton inst; static UploaderSingleton inst;
return inst; return inst;
} }
void registerUploader(Uploader *uploader); void registerUploader(Uploader *uploader);
void upload(QPixmap *pixmap); void upload(QPixmap *pixmap);
QList<Uploader *> uploaderList(); QList<Uploader *> uploaderList();
void set(QString uploader); void set(QString uploader);
QString selectedUploader(); QString selectedUploader();
QList<std::runtime_error> errors(); QList<std::runtime_error> errors();
signals: signals:
void newUploader(Uploader *u); void newUploader(Uploader *u);
private: private:
UploaderSingleton(); UploaderSingleton();
QMap<QString, Uploader *> uploaders; QMap<QString, Uploader *> uploaders;
QString uploader = "imgur"; QString uploader = "imgur";
QList<std::runtime_error> errs; QList<std::runtime_error> errs;
}; };
#endif // UPLOADERSINGLETON_HPP #endif // UPLOADERSINGLETON_HPP