benkyd/flameshot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Code refactoring - change code style to the new clang-format rules

Browse Source
This commit is contained in:
Yuriy Puchkov
2020-09-23 15:24:16 +03:00
parent 5a62cd3b13
commit b88a5fbce8
175 changed files with 6200 additions and 5356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/tools/abstractactiontool.cpp
View File

@@ -17,55 +17,67 @@
#include "abstractactiontool.h"
AbstractActionTool::AbstractActionTool(QObject *parent) : CaptureTool(parent) {
AbstractActionTool::AbstractActionTool(QObject* parent)
: CaptureTool(parent)
{}
}
bool AbstractActionTool::isValid() const {
bool AbstractActionTool::isValid() const
{
return true;
}
bool AbstractActionTool::isSelectable() const {
bool AbstractActionTool::isSelectable() const
{
return false;
}
bool AbstractActionTool::showMousePreview() const {
bool AbstractActionTool::showMousePreview() const
{
return false;
}
void AbstractActionTool::undo(QPixmap &pixmap) {
void AbstractActionTool::undo(QPixmap& pixmap)
{
Q_UNUSED(pixmap);
}
void AbstractActionTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void AbstractActionTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
Q_UNUSED(painter);
Q_UNUSED(pixmap);
Q_UNUSED(recordUndo);
}
void AbstractActionTool::paintMousePreview(
QPainter &painter, const CaptureContext &context)
void AbstractActionTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
Q_UNUSED(painter);
Q_UNUSED(context);
}
void AbstractActionTool::drawEnd(const QPoint &p) {
void AbstractActionTool::drawEnd(const QPoint& p)
{
Q_UNUSED(p);
}
void AbstractActionTool::drawMove(const QPoint &p) {
void AbstractActionTool::drawMove(const QPoint& p)
{
Q_UNUSED(p);
}
void AbstractActionTool::drawStart(const CaptureContext &context) {
void AbstractActionTool::drawStart(const CaptureContext& context)
{
Q_UNUSED(context);
}
void AbstractActionTool::colorChanged(const QColor &c) {
void AbstractActionTool::colorChanged(const QColor& c)
{
Q_UNUSED(c);
}
void AbstractActionTool::thicknessChanged(const int th) {
void AbstractActionTool::thicknessChanged(const int th)
{
Q_UNUSED(th);
}

22
src/tools/abstractactiontool.h
View File

@@ -19,23 +19,27 @@
#include "capturetool.h"
class AbstractActionTool : public CaptureTool {
class AbstractActionTool : public CaptureTool
{
Q_OBJECT
public:
explicit AbstractActionTool(QObject *parent = nullptr);
explicit AbstractActionTool(QObject* parent = nullptr);
bool isValid() const override;
bool isSelectable() const override;
bool showMousePreview() const override;
void undo(QPixmap &pixmap) override;
void process(QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
void undo(QPixmap& pixmap) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawEnd(const QPoint &p) override;
void drawMove(const QPoint &p) override;
void drawStart(const CaptureContext &context) override;
void colorChanged(const QColor &c) override;
void drawEnd(const QPoint& p) override;
void drawMove(const QPoint& p) override;
void drawStart(const CaptureContext& context) override;
void colorChanged(const QColor& c) override;
void thicknessChanged(const int th) override;
};

46
src/tools/abstractpathtool.cpp
View File

@@ -17,59 +17,69 @@
#include "abstractpathtool.h"
AbstractPathTool::AbstractPathTool(QObject *parent) :
CaptureTool(parent), m_thickness(0), m_padding(0)
AbstractPathTool::AbstractPathTool(QObject* parent)
: CaptureTool(parent)
, m_thickness(0)
, m_padding(0)
{}
bool AbstractPathTool::isValid() const
{
}
bool AbstractPathTool::isValid() const {
return m_points.length() > 1;
}
bool AbstractPathTool::closeOnButtonPressed() const {
bool AbstractPathTool::closeOnButtonPressed() const
{
return false;
}
bool AbstractPathTool::isSelectable() const {
bool AbstractPathTool::isSelectable() const
{
return true;
}
bool AbstractPathTool::showMousePreview() const {
bool AbstractPathTool::showMousePreview() const
{
return true;
}
void AbstractPathTool::undo(QPixmap &pixmap) {
void AbstractPathTool::undo(QPixmap& pixmap)
{
QPainter p(&pixmap);
const int val = m_thickness + m_padding;
QRect area = m_backupArea + QMargins(val, val, val, val);
p.drawPixmap(area.intersected(pixmap.rect())
.topLeft(), m_pixmapBackup);
p.drawPixmap(area.intersected(pixmap.rect()).topLeft(), m_pixmapBackup);
}
void AbstractPathTool::drawEnd(const QPoint &p) {
void AbstractPathTool::drawEnd(const QPoint& p)
{
Q_UNUSED(p);
}
void AbstractPathTool::drawMove(const QPoint &p) {
void AbstractPathTool::drawMove(const QPoint& p)
{
addPoint(p);
}
void AbstractPathTool::colorChanged(const QColor &c) {
void AbstractPathTool::colorChanged(const QColor& c)
{
m_color = c;
}
void AbstractPathTool::thicknessChanged(const int th) {
void AbstractPathTool::thicknessChanged(const int th)
{
m_thickness = th;
}
void AbstractPathTool::updateBackup(const QPixmap &pixmap) {
void AbstractPathTool::updateBackup(const QPixmap& pixmap)
{
const int val = m_thickness + m_padding;
QRect area = m_backupArea.normalized() + QMargins(val, val, val, val);
m_pixmapBackup = pixmap.copy(area);
}
void AbstractPathTool::addPoint(const QPoint &point) {
void AbstractPathTool::addPoint(const QPoint& point)
{
if (m_backupArea.left() > point.x()) {
m_backupArea.setLeft(point.x());
} else if (m_backupArea.right() < point.x()) {

17
src/tools/abstractpathtool.h
View File

@@ -19,27 +19,28 @@
#include "capturetool.h"
class AbstractPathTool : public CaptureTool {
class AbstractPathTool : public CaptureTool
{
Q_OBJECT
public:
explicit AbstractPathTool(QObject *parent = nullptr);
explicit AbstractPathTool(QObject* parent = nullptr);
bool isValid() const override;
bool closeOnButtonPressed() const override;
bool isSelectable() const override;
bool showMousePreview() const override;
void undo(QPixmap &pixmap) override;
void undo(QPixmap& pixmap) override;
public slots:
void drawEnd(const QPoint &p) override;
void drawMove(const QPoint &p) override;
void colorChanged(const QColor &c) override;
void drawEnd(const QPoint& p) override;
void drawMove(const QPoint& p) override;
void colorChanged(const QColor& c) override;
void thicknessChanged(const int th) override;
protected:
void updateBackup(const QPixmap &pixmap);
void addPoint(const QPoint &point);
void updateBackup(const QPixmap& pixmap);
void addPoint(const QPoint& point);
QPixmap m_pixmapBackup;
QRect m_backupArea;

66
src/tools/abstracttwopointtool.cpp
View File

@@ -23,7 +23,8 @@ namespace {
const double ADJ_UNIT = std::atan(1.0);
const int DIRS_NUMBER = 4;
enum UNIT {
enum UNIT
{
HORIZ_DIR = 0,
DIAG1_DIR = 1,
VERT_DIR = 2,
@@ -33,74 +34,90 @@ enum UNIT {
const double ADJ_DIAG_UNIT = 2 * ADJ_UNIT;
const int DIAG_DIRS_NUMBER = 2;
enum DIAG_UNIT {
enum DIAG_UNIT
{
DIR1 = 0,
DIR2 = 1
};
}
AbstractTwoPointTool::AbstractTwoPointTool(QObject *parent) :
CaptureTool(parent), m_thickness(0), m_padding(0)
AbstractTwoPointTool::AbstractTwoPointTool(QObject* parent)
: CaptureTool(parent)
, m_thickness(0)
, m_padding(0)
{}
bool AbstractTwoPointTool::isValid() const
{
}
bool AbstractTwoPointTool::isValid() const {
return (m_points.first != m_points.second);
}
bool AbstractTwoPointTool::closeOnButtonPressed() const {
bool AbstractTwoPointTool::closeOnButtonPressed() const
{
return false;
}
bool AbstractTwoPointTool::isSelectable() const {
bool AbstractTwoPointTool::isSelectable() const
{
return true;
}
bool AbstractTwoPointTool::showMousePreview() const {
bool AbstractTwoPointTool::showMousePreview() const
{
return true;
}
void AbstractTwoPointTool::undo(QPixmap &pixmap) {
void AbstractTwoPointTool::undo(QPixmap& pixmap)
{
QPainter p(&pixmap);
p.drawPixmap(backupRect(pixmap.rect()).topLeft(), m_pixmapBackup);
}
void AbstractTwoPointTool::drawEnd(const QPoint &p) {
void AbstractTwoPointTool::drawEnd(const QPoint& p)
{
Q_UNUSED(p);
}
void AbstractTwoPointTool::drawMove(const QPoint &p) {
void AbstractTwoPointTool::drawMove(const QPoint& p)
{
m_points.second = p;
}
void AbstractTwoPointTool::drawMoveWithAdjustment(const QPoint &p) {
void AbstractTwoPointTool::drawMoveWithAdjustment(const QPoint& p)
{
m_points.second = m_points.first + adjustedVector(p - m_points.first);
}
void AbstractTwoPointTool::colorChanged(const QColor &c) {
void AbstractTwoPointTool::colorChanged(const QColor& c)
{
m_color = c;
}
void AbstractTwoPointTool::thicknessChanged(const int th) {
void AbstractTwoPointTool::thicknessChanged(const int th)
{
m_thickness = th;
}
void AbstractTwoPointTool::updateBackup(const QPixmap &pixmap) {
void AbstractTwoPointTool::updateBackup(const QPixmap& pixmap)
{
m_pixmapBackup = pixmap.copy(backupRect(pixmap.rect()));
}
QRect AbstractTwoPointTool::backupRect(const QRect &limits) const {
QRect AbstractTwoPointTool::backupRect(const QRect& limits) const
{
QRect r = QRect(m_points.first, m_points.second).normalized();
const int val = m_thickness + m_padding;
r += QMargins(val, val, val, val);
return r.intersected(limits);
}
QPoint AbstractTwoPointTool::adjustedVector(QPoint v) const {
QPoint AbstractTwoPointTool::adjustedVector(QPoint v) const
{
if (m_supportsOrthogonalAdj && m_supportsDiagonalAdj) {
int dir = ( static_cast<int>(round(atan2(-v.y(), v.x()) / ADJ_UNIT)) + DIRS_NUMBER ) % DIRS_NUMBER;
int dir = (static_cast<int>(round(atan2(-v.y(), v.x()) / ADJ_UNIT)) +
DIRS_NUMBER) %
DIRS_NUMBER;
if (dir == UNIT::HORIZ_DIR) {
v.setY(0);
} else if (dir == UNIT::VERT_DIR) {
@@ -117,8 +134,11 @@ QPoint AbstractTwoPointTool::adjustedVector(QPoint v) const {
v.setY(newY);
}
} else if (m_supportsDiagonalAdj) {
int dir = ( static_cast<int>(round((atan2(-v.y(), v.x()) - ADJ_DIAG_UNIT / 2) / ADJ_DIAG_UNIT))
+ DIAG_DIRS_NUMBER ) % DIAG_DIRS_NUMBER;
int dir =
(static_cast<int>(round((atan2(-v.y(), v.x()) - ADJ_DIAG_UNIT / 2) /
ADJ_DIAG_UNIT)) +
DIAG_DIRS_NUMBER) %
DIAG_DIRS_NUMBER;
if (dir == DIAG_UNIT::DIR1) {
int newX = (v.x() - v.y()) / 2;
int newY = -newX;

19
src/tools/abstracttwopointtool.h
View File

@@ -19,28 +19,29 @@
#include "capturetool.h"
class AbstractTwoPointTool : public CaptureTool {
class AbstractTwoPointTool : public CaptureTool
{
Q_OBJECT
public:
explicit AbstractTwoPointTool(QObject *parent = nullptr);
explicit AbstractTwoPointTool(QObject* parent = nullptr);
bool isValid() const override;
bool closeOnButtonPressed() const override;
bool isSelectable() const override;
bool showMousePreview() const override;
void undo(QPixmap &pixmap) override;
void undo(QPixmap& pixmap) override;
public slots:
void drawEnd(const QPoint &p) override;
void drawMove(const QPoint &p) override;
void drawMoveWithAdjustment(const QPoint &p) override;
void colorChanged(const QColor &c) override;
void drawEnd(const QPoint& p) override;
void drawMove(const QPoint& p) override;
void drawMoveWithAdjustment(const QPoint& p) override;
void colorChanged(const QColor& c) override;
void thicknessChanged(const int th) override;
protected:
void updateBackup(const QPixmap &pixmap);
QRect backupRect(const QRect &limits) const;
void updateBackup(const QPixmap& pixmap);
QRect backupRect(const QRect& limits) const;
QPixmap m_pixmapBackup;
QPair<QPoint, QPoint> m_points;

64
src/tools/arrow/arrowtool.cpp
View File

@@ -24,25 +24,26 @@ namespace {
const int ArrowWidth = 10;
const int ArrowHeight = 18;
QPainterPath getArrowHead(QPoint p1, QPoint p2, const int thickness) {
QPainterPath getArrowHead(QPoint p1, QPoint p2, const int thickness)
{
QLineF base(p1, p2);
// Create the vector for the position of the base of the arrowhead
QLineF temp(QPoint(0,0), p2-p1);
int val = ArrowHeight + thickness*4;
QLineF temp(QPoint(0, 0), p2 - p1);
int val = ArrowHeight + thickness * 4;
if (base.length() < val) {
val = (base.length() + thickness*2);
val = (base.length() + thickness * 2);
}
temp.setLength(base.length() + thickness*2 - val);
temp.setLength(base.length() + thickness * 2 - val);
// Move across the line up to the head
QPointF bottonTranslation(temp.p2());
// Rotate base of the arrowhead
base.setLength(ArrowWidth + thickness*2);
base.setLength(ArrowWidth + thickness * 2);
base.setAngle(base.angle() + 90);
// Move to the correct point
QPointF temp2 = p1 - base.p2();
// Center it
QPointF centerTranslation((temp2.x()/2), (temp2.y()/2));
QPointF centerTranslation((temp2.x() / 2), (temp2.y() / 2));
base.translate(bottonTranslation);
base.translate(centerTranslation);
@@ -56,65 +57,82 @@ QPainterPath getArrowHead(QPoint p1, QPoint p2, const int thickness) {
}
// gets a shorter line to prevent overlap in the point of the arrow
QLine getShorterLine(QPoint p1, QPoint p2, const int thickness) {
QLine getShorterLine(QPoint p1, QPoint p2, const int thickness)
{
QLineF l(p1, p2);
int val = ArrowHeight + thickness*4;
int val = ArrowHeight + thickness * 4;
if (l.length() < val) {
val = (l.length() + thickness*2);
val = (l.length() + thickness * 2);
}
l.setLength(l.length() + thickness*2 - val);
l.setLength(l.length() + thickness * 2 - val);
return l.toLine();
}
} // unnamed namespace
ArrowTool::ArrowTool(QObject *parent) : AbstractTwoPointTool(parent) {
ArrowTool::ArrowTool(QObject* parent)
: AbstractTwoPointTool(parent)
{
m_padding = ArrowWidth / 2;
m_supportsOrthogonalAdj = true;
m_supportsDiagonalAdj = true;
}
QIcon ArrowTool::icon(const QColor &background, bool inEditor) const {
QIcon ArrowTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "arrow-bottom-left.svg");
}
QString ArrowTool::name() const {
QString ArrowTool::name() const
{
return tr("Arrow");
}
QString ArrowTool::nameID() {
QString ArrowTool::nameID()
{
return QLatin1String("");
}
QString ArrowTool::description() const {
QString ArrowTool::description() const
{
return tr("Set the Arrow as the paint tool");
}
CaptureTool* ArrowTool::copy(QObject *parent) {
CaptureTool* ArrowTool::copy(QObject* parent)
{
return new ArrowTool(parent);
}
void ArrowTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void ArrowTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (recordUndo) {
updateBackup(pixmap);
}
painter.setPen(QPen(m_color, m_thickness));
painter.drawLine(getShorterLine(m_points.first, m_points.second, m_thickness));
painter.fillPath(getArrowHead(m_points.first, m_points.second, m_thickness), QBrush(m_color));
painter.drawLine(
getShorterLine(m_points.first, m_points.second, m_thickness));
painter.fillPath(getArrowHead(m_points.first, m_points.second, m_thickness),
QBrush(m_color));
}
void ArrowTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void ArrowTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
painter.setPen(QPen(context.color, PADDING_VALUE + context.thickness));
painter.drawLine(context.mousePos, context.mousePos);
}
void ArrowTool::drawStart(const CaptureContext &context) {
void ArrowTool::drawStart(const CaptureContext& context)
{
m_color = context.color;
m_thickness = context.thickness + PADDING_VALUE;
m_points.first = context.mousePos;
m_points.second = context.mousePos;
}
void ArrowTool::pressed(const CaptureContext &context) {
void ArrowTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}

21
src/tools/arrow/arrowtool.h
View File

@@ -20,22 +20,25 @@
#include "src/tools/abstracttwopointtool.h"
#include <QPainter>
class ArrowTool : public AbstractTwoPointTool {
class ArrowTool : public AbstractTwoPointTool
{
Q_OBJECT
public:
explicit ArrowTool(QObject *parent = nullptr);
explicit ArrowTool(QObject* parent = nullptr);
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
};

55
src/tools/blur/blurtool.cpp
View File

@@ -16,51 +16,60 @@
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "blurtool.h"
#include <QPainter>
#include <QApplication>
#include <QGraphicsBlurEffect>
#include <QGraphicsPixmapItem>
#include <QGraphicsScene>
#include <QApplication>
#include <QPainter>
BlurTool::BlurTool(QObject *parent) : AbstractTwoPointTool(parent) {
BlurTool::BlurTool(QObject* parent)
: AbstractTwoPointTool(parent)
{}
}
QIcon BlurTool::icon(const QColor &background, bool inEditor) const {
QIcon BlurTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "blur.svg");
}
QString BlurTool::name() const {
QString BlurTool::name() const
{
return tr("Blur");
}
QString BlurTool::nameID() {
QString BlurTool::nameID()
{
return QLatin1String("");
}
QString BlurTool::description() const {
QString BlurTool::description() const
{
return tr("Set Blur as the paint tool");
}
CaptureTool* BlurTool::copy(QObject *parent) {
CaptureTool* BlurTool::copy(QObject* parent)
{
return new BlurTool(parent);
}
void BlurTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void BlurTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (recordUndo) {
updateBackup(pixmap);
}
QPoint &p0 = m_points.first;
QPoint &p1 = m_points.second;
QPoint& p0 = m_points.first;
QPoint& p1 = m_points.second;
auto pixelRatio = pixmap.devicePixelRatio();
QRect selection = QRect(p0, p1).normalized();
QRect selectionScaled = QRect(p0 * pixelRatio, p1 * pixelRatio).normalized();
QRect selectionScaled =
QRect(p0 * pixelRatio, p1 * pixelRatio).normalized();
QGraphicsBlurEffect *blur = new QGraphicsBlurEffect;
QGraphicsBlurEffect* blur = new QGraphicsBlurEffect;
blur->setBlurRadius(10);
QGraphicsPixmapItem *item = new QGraphicsPixmapItem (
pixmap.copy(selectionScaled));
QGraphicsPixmapItem* item =
new QGraphicsPixmapItem(pixmap.copy(selectionScaled));
item->setGraphicsEffect(blur);
QGraphicsScene scene;
@@ -68,22 +77,26 @@ void BlurTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo
scene.render(&painter, selection, QRectF());
blur->setBlurRadius(12);
for(int cnt = 100; cnt > 0; cnt--){
for (int cnt = 100; cnt > 0; cnt--) {
scene.render(&painter, selection, QRectF());
}
}
void BlurTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void BlurTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
Q_UNUSED(context);
Q_UNUSED(painter);
}
void BlurTool::drawStart(const CaptureContext &context) {
void BlurTool::drawStart(const CaptureContext& context)
{
m_thickness = context.thickness;
m_points.first = context.mousePos;
m_points.second = context.mousePos;
}
void BlurTool::pressed(const CaptureContext &context) {
void BlurTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}

21
src/tools/blur/blurtool.h
View File

@@ -19,22 +19,25 @@
#include "src/tools/abstracttwopointtool.h"
class BlurTool : public AbstractTwoPointTool {
class BlurTool : public AbstractTwoPointTool
{
Q_OBJECT
public:
explicit BlurTool(QObject *parent = nullptr);
explicit BlurTool(QObject* parent = nullptr);
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
};

3
src/tools/capturecontext.cpp
View File

@@ -17,7 +17,8 @@
#include "capturecontext.h"
QPixmap CaptureContext::selectedScreenshotArea() const {
QPixmap CaptureContext::selectedScreenshotArea() const
{
if (selection.isNull()) {
return screenshot;
} else {

11
src/tools/capturecontext.h
View File

@@ -17,12 +17,13 @@
#pragma once
#include <QRect>
#include <QPoint>
#include <QPixmap>
#include <QPainter>
#include <QPixmap>
#include <QPoint>
#include <QRect>
struct CaptureContext {
struct CaptureContext
{
// screenshot with modifications
QPixmap screenshot;
// unmodified screenshot
@@ -44,5 +45,5 @@ struct CaptureContext {
// Mode of the capture widget
bool fullscreen;
QPixmap selectedScreenshotArea() const ;
QPixmap selectedScreenshotArea() const;
};

59
src/tools/capturetool.h
View File

@@ -23,12 +23,14 @@
#include <QIcon>
#include <QPainter>
class CaptureTool : public QObject {
class CaptureTool : public QObject
{
Q_OBJECT
public:
// Request actions on the main widget
enum Request {
enum Request
{
// Call close() in the editor.
REQ_CLOSE_GUI,
// Call hide() in the editor.
@@ -64,9 +66,11 @@ public:
REQ_ADD_EXTERNAL_WIDGETS,
};
explicit CaptureTool(QObject *parent = nullptr) : QObject(parent){}
explicit CaptureTool(QObject* parent = nullptr)
: QObject(parent)
{}
virtual void setCapture(const QPixmap &pixmap) {};
virtual void setCapture(const QPixmap& pixmap){};
// Returns false when the tool is in an inconsistent state and shouldn't
// be included in the tool undo/redo stack.
@@ -82,8 +86,7 @@ public:
// The icon of the tool.
// inEditor is true when the icon is requested inside the editor
// and false otherwise.
virtual QIcon icon(const QColor &background,
bool inEditor) const = 0;
virtual QIcon icon(const QColor& background, bool inEditor) const = 0;
// Name displayed for the tool, this could be translated with tr()
virtual QString name() const = 0;
// Codename for the tool, this hsouldn't change as it is used as ID
@@ -95,59 +98,53 @@ public:
// if the type is TYPE_WIDGET the widget is loaded in the main widget.
// If the type is TYPE_EXTERNAL_WIDGET it is created outside as an
// individual widget.
virtual QWidget* widget() {
return nullptr;
}
virtual QWidget* widget() { return nullptr; }
// When the tool is selected this method is called and the widget is added
// to the configuration panel inside the main widget.
virtual QWidget* configurationWidget() {
return nullptr;
}
virtual QWidget* configurationWidget() { return nullptr; }
// Permanent configuration used in the configuration outside of the
// capture.
virtual QWidget* permanentConfigurationWidget() {
return nullptr;
}
virtual QWidget* permanentConfigurationWidget() { return nullptr; }
// Return a copy of the tool
virtual CaptureTool* copy(QObject *parent = nullptr) = 0;
virtual CaptureTool* copy(QObject* parent = nullptr) = 0;
// revert changes
virtual void undo(QPixmap &pixmap) = 0;
virtual void undo(QPixmap& pixmap) = 0;
// Called every time the tool has to draw
// recordUndo indicates when the tool should save the information
// for the undo(), if the value is false calling undo() after
// that process should not modify revert the changes.
virtual void process(QPainter &painter,
const QPixmap &pixmap,
virtual void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) = 0;
// When the tool is selected, this is called when the mouse moves
virtual void paintMousePreview(QPainter &painter, const CaptureContext &context) = 0;
virtual void paintMousePreview(QPainter& painter,
const CaptureContext& context) = 0;
signals:
void requestAction(Request r);
protected:
QString iconPath(const QColor &c) const {
return ColorUtils::colorIsDark(c) ?
PathInfo::whiteIconPath() : PathInfo::blackIconPath();
QString iconPath(const QColor& c) const
{
return ColorUtils::colorIsDark(c) ? PathInfo::whiteIconPath()
: PathInfo::blackIconPath();
}
public slots:
// On mouse release.
virtual void drawEnd(const QPoint &p) = 0;
virtual void drawEnd(const QPoint& p) = 0;
// Mouse pressed and moving, called once a pixel.
virtual void drawMove(const QPoint &p) = 0;
virtual void drawMove(const QPoint& p) = 0;
// Called when drawMove is needed with an adjustment;
// should be overridden in case an adjustment is applicable.
virtual void drawMoveWithAdjustment(const QPoint &p) {
drawMove(p);
}
virtual void drawMoveWithAdjustment(const QPoint& p) { drawMove(p); }
// Called when the tool is activated.
virtual void drawStart(const CaptureContext &context) = 0;
virtual void drawStart(const CaptureContext& context) = 0;
// Called right after pressign the button which activates the tool.
virtual void pressed(const CaptureContext &context) = 0;
virtual void pressed(const CaptureContext& context) = 0;
// Called when the color is changed in the editor.
virtual void colorChanged(const QColor &c) = 0;
virtual void colorChanged(const QColor& c) = 0;
// Called when the thickness of the tool is updated in the editor.
virtual void thicknessChanged(const int th) = 0;
};

34
src/tools/circle/circletool.cpp
View File

@@ -22,31 +22,41 @@ namespace {
#define PADDING_VALUE 2
}
CircleTool::CircleTool(QObject *parent) : AbstractTwoPointTool(parent) {
CircleTool::CircleTool(QObject* parent)
: AbstractTwoPointTool(parent)
{
m_supportsDiagonalAdj = true;
}
QIcon CircleTool::icon(const QColor &background, bool inEditor) const {
QIcon CircleTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "circle-outline.svg");
}
QString CircleTool::name() const {
QString CircleTool::name() const
{
return tr("Circle");
}
QString CircleTool::nameID() {
QString CircleTool::nameID()
{
return QLatin1String("");
}
QString CircleTool::description() const {
QString CircleTool::description() const
{
return tr("Set the Circle as the paint tool");
}
CaptureTool* CircleTool::copy(QObject *parent) {
CaptureTool* CircleTool::copy(QObject* parent)
{
return new CircleTool(parent);
}
void CircleTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void CircleTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (recordUndo) {
updateBackup(pixmap);
}
@@ -54,18 +64,22 @@ void CircleTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUn
painter.drawEllipse(QRect(m_points.first, m_points.second));
}
void CircleTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void CircleTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
painter.setPen(QPen(context.color, PADDING_VALUE + context.thickness));
painter.drawLine(context.mousePos, context.mousePos);
}
void CircleTool::drawStart(const CaptureContext &context) {
void CircleTool::drawStart(const CaptureContext& context)
{
m_color = context.color;
m_thickness = context.thickness + PADDING_VALUE;
m_points.first = context.mousePos;
m_points.second = context.mousePos;
}
void CircleTool::pressed(const CaptureContext &context) {
void CircleTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}

21
src/tools/circle/circletool.h
View File

@@ -19,22 +19,25 @@
#include "src/tools/abstracttwopointtool.h"
class CircleTool : public AbstractTwoPointTool {
class CircleTool : public AbstractTwoPointTool
{
Q_OBJECT
public:
explicit CircleTool(QObject *parent = nullptr);
explicit CircleTool(QObject* parent = nullptr);
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
};

27
src/tools/copy/copytool.cpp
View File

@@ -19,35 +19,42 @@
#include "src/utils/screenshotsaver.h"
#include <QPainter>
CopyTool::CopyTool(QObject *parent) : AbstractActionTool(parent) {
CopyTool::CopyTool(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool CopyTool::closeOnButtonPressed() const {
bool CopyTool::closeOnButtonPressed() const
{
return true;
}
QIcon CopyTool::icon(const QColor &background, bool inEditor) const {
QIcon CopyTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "content-copy.svg");
}
QString CopyTool::name() const {
QString CopyTool::name() const
{
return tr("Copy");
}
QString CopyTool::nameID() {
QString CopyTool::nameID()
{
return QLatin1String("");
}
QString CopyTool::description() const {
QString CopyTool::description() const
{
return tr("Copy the selection into the clipboard");
}
CaptureTool* CopyTool::copy(QObject *parent) {
CaptureTool* CopyTool::copy(QObject* parent)
{
return new CopyTool(parent);
}
void CopyTool::pressed(const CaptureContext &context) {
void CopyTool::pressed(const CaptureContext& context)
{
emit requestAction(REQ_CAPTURE_DONE_OK);
ScreenshotSaver().saveToClipboard(context.selectedScreenshotArea());
}

11
src/tools/copy/copytool.h
View File

@@ -19,20 +19,21 @@
#include "src/tools/abstractactiontool.h"
class CopyTool : public AbstractActionTool {
class CopyTool : public AbstractActionTool
{
Q_OBJECT
public:
explicit CopyTool(QObject *parent = nullptr);
explicit CopyTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
};

27
src/tools/exit/exittool.cpp
View File

@@ -18,35 +18,42 @@
#include "exittool.h"
#include <QPainter>
ExitTool::ExitTool(QObject *parent) : AbstractActionTool(parent) {
ExitTool::ExitTool(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool ExitTool::closeOnButtonPressed() const {
bool ExitTool::closeOnButtonPressed() const
{
return true;
}
QIcon ExitTool::icon(const QColor &background, bool inEditor) const {
QIcon ExitTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "close.svg");
}
QString ExitTool::name() const {
QString ExitTool::name() const
{
return tr("Exit");
}
QString ExitTool::nameID() {
QString ExitTool::nameID()
{
return QLatin1String("");
}
QString ExitTool::description() const {
QString ExitTool::description() const
{
return tr("Leave the capture screen");
}
CaptureTool* ExitTool::copy(QObject *parent) {
CaptureTool* ExitTool::copy(QObject* parent)
{
return new ExitTool(parent);
}
void ExitTool::pressed(const CaptureContext &context) {
void ExitTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
emit requestAction(REQ_CLOSE_GUI);
}

11
src/tools/exit/exittool.h
View File

@@ -19,20 +19,21 @@
#include "src/tools/abstractactiontool.h"
class ExitTool : public AbstractActionTool {
class ExitTool : public AbstractActionTool
{
Q_OBJECT
public:
explicit ExitTool(QObject *parent = nullptr);
explicit ExitTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
};

30
src/tools/launcher/applaunchertool.cpp
View File

@@ -18,39 +18,47 @@
#include "applaunchertool.h"
#include "applauncherwidget.h"
AppLauncher::AppLauncher(QObject *parent) : AbstractActionTool(parent) {
AppLauncher::AppLauncher(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool AppLauncher::closeOnButtonPressed() const {
bool AppLauncher::closeOnButtonPressed() const
{
return true;
}
QIcon AppLauncher::icon(const QColor &background, bool inEditor) const {
QIcon AppLauncher::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "open_with.svg");
}
QString AppLauncher::name() const {
QString AppLauncher::name() const
{
return tr("App Launcher");
}
QString AppLauncher::nameID() {
QString AppLauncher::nameID()
{
return QLatin1String("");
}
QString AppLauncher::description() const {
QString AppLauncher::description() const
{
return tr("Choose an app to open the capture");
}
QWidget* AppLauncher::widget() {
QWidget* AppLauncher::widget()
{
return new AppLauncherWidget(capture);
}
CaptureTool* AppLauncher::copy(QObject *parent) {
CaptureTool* AppLauncher::copy(QObject* parent)
{
return new AppLauncher(parent);
}
void AppLauncher::pressed(const CaptureContext &context) {
void AppLauncher::pressed(const CaptureContext& context)
{
capture = context.selectedScreenshotArea();
emit requestAction(REQ_CAPTURE_DONE_OK);
emit requestAction(REQ_ADD_EXTERNAL_WIDGETS);

11
src/tools/launcher/applaunchertool.h
View File

@@ -19,24 +19,25 @@
#include "src/tools/abstractactiontool.h"
class AppLauncher : public AbstractActionTool {
class AppLauncher : public AbstractActionTool
{
Q_OBJECT
public:
explicit AppLauncher(QObject *parent = nullptr);
explicit AppLauncher(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
QWidget* widget() override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
private:
QPixmap capture;

163
src/tools/launcher/applauncherwidget.cpp
View File

@@ -16,40 +16,40 @@
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "applauncherwidget.h"
#include "src/utils/filenamehandler.h"
#include "src/tools/launcher/launcheritemdelegate.h"
#include "src/utils/globalvalues.h"
#include "src/utils/confighandler.h"
#include "src/utils/filenamehandler.h"
#include "src/utils/globalvalues.h"
#include "terminallauncher.h"
#include <QDir>
#include <QList>
#include <QProcess>
#include <QPixmap>
#include <QListView>
#include <QTabWidget>
#include <QListWidgetItem>
#include <QHBoxLayout>
#include <QCheckBox>
#include <QDir>
#include <QHBoxLayout>
#include <QLineEdit>
#include <QList>
#include <QListView>
#include <QListWidgetItem>
#include <QMessageBox>
#include <QPixmap>
#include <QProcess>
#include <QTabWidget>
namespace {
QMap<QString, QString> catIconNames({
{ "Multimedia", "applications-multimedia" },
{ "Development","applications-development" },
{ "Graphics", "applications-graphics" },
{ "Network", "preferences-system-network" },
{ "Office", "applications-office" },
{ "Science", "applications-science" },
{ "Settings", "preferences-desktop" },
{ "System", "preferences-system" },
{ "Utility", "applications-utilities" }
});
QMap<QString, QString> catIconNames(
{ { "Multimedia", "applications-multimedia" },
{ "Development", "applications-development" },
{ "Graphics", "applications-graphics" },
{ "Network", "preferences-system-network" },
{ "Office", "applications-office" },
{ "Science", "applications-science" },
{ "Settings", "preferences-desktop" },
{ "System", "preferences-system" },
{ "Utility", "applications-utilities" } });
}
AppLauncherWidget::AppLauncherWidget(const QPixmap &p, QWidget *parent):
QWidget(parent), m_pixmap(p)
AppLauncherWidget::AppLauncherWidget(const QPixmap& p, QWidget* parent)
: QWidget(parent)
, m_pixmap(p)
{
setAttribute(Qt::WA_DeleteOnClose);
setWindowIcon(QIcon(":img/app/flameshot.svg"));
@@ -71,16 +71,22 @@ AppLauncherWidget::AppLauncherWidget(const QPixmap &p, QWidget *parent):
m_terminalCheckbox = new QCheckBox(tr("Launch in terminal"), this);
m_keepOpenCheckbox = new QCheckBox(tr("Keep open after selection"), this);
m_keepOpenCheckbox->setChecked(ConfigHandler().keepOpenAppLauncherValue());
connect(m_keepOpenCheckbox, &QCheckBox::clicked, this, &AppLauncherWidget::checkboxClicked);
connect(m_keepOpenCheckbox,
&QCheckBox::clicked,
this,
&AppLauncherWidget::checkboxClicked);
// search items
m_lineEdit = new QLineEdit;
connect(m_lineEdit, &QLineEdit::textChanged,
this, &AppLauncherWidget::searchChanged);
connect(m_lineEdit,
&QLineEdit::textChanged,
this,
&AppLauncherWidget::searchChanged);
m_filterList = new QListWidget;
m_filterList->hide();
configureListView(m_filterList);
connect(m_filterList, &QListWidget::clicked, this, &AppLauncherWidget::launch);
connect(
m_filterList, &QListWidget::clicked, this, &AppLauncherWidget::launch);
m_layout = new QVBoxLayout(this);
m_layout->addWidget(m_filterList);
@@ -91,25 +97,28 @@ AppLauncherWidget::AppLauncherWidget(const QPixmap &p, QWidget *parent):
m_lineEdit->setFocus();
}
void AppLauncherWidget::launch(const QModelIndex &index) {
void AppLauncherWidget::launch(const QModelIndex& index)
{
if (!QFileInfo(m_tempFile).isReadable()) {
m_tempFile = FileNameHandler().generateAbsolutePath(QDir::tempPath()) + ".png";
m_tempFile =
FileNameHandler().generateAbsolutePath(QDir::tempPath()) + ".png";
bool ok = m_pixmap.save(m_tempFile);
if (!ok) {
QMessageBox::about(this, tr("Error"), tr("Unable to write in")
+ QDir::tempPath());
QMessageBox::about(
this, tr("Error"), tr("Unable to write in") + QDir::tempPath());
return;
}
}
QString command = index.data(Qt::UserRole).toString().replace(
QRegExp("(\\%.)"), '"' + m_tempFile + '"');
bool inTerminal = index.data(Qt::UserRole+1).toBool() ||
m_terminalCheckbox->isChecked();
QString command = index.data(Qt::UserRole)
.toString()
.replace(QRegExp("(\\%.)"), '"' + m_tempFile + '"');
bool inTerminal =
index.data(Qt::UserRole + 1).toBool() || m_terminalCheckbox->isChecked();
if (inTerminal) {
bool ok = TerminalLauncher::launchDetached(command);
if (!ok) {
QMessageBox::about(this, tr("Error"),
tr("Unable to launch in terminal."));
QMessageBox::about(
this, tr("Error"), tr("Unable to launch in terminal."));
}
} else {
QProcess::startDetached(command);
@@ -119,13 +128,15 @@ void AppLauncherWidget::launch(const QModelIndex &index) {
}
}
void AppLauncherWidget::checkboxClicked(const bool enabled) {
void AppLauncherWidget::checkboxClicked(const bool enabled)
{
m_keepOpen = enabled;
ConfigHandler().setKeepOpenAppLauncher(enabled);
m_keepOpenCheckbox->setChecked(enabled);
}
void AppLauncherWidget::searchChanged(const QString &text) {
void AppLauncherWidget::searchChanged(const QString& text)
{
if (text.isEmpty()) {
m_filterList->hide();
m_tabWidget->show();
@@ -137,15 +148,14 @@ void AppLauncherWidget::searchChanged(const QString &text) {
QVector<DesktopAppData> apps;
for (auto const& i : catIconNames.toStdMap()) {
const QString &cat = i.first;
const QString& cat = i.first;
if (!m_appsMap.contains(cat)) {
continue;
}
const QVector<DesktopAppData> &appList = m_appsMap[cat];
for (const DesktopAppData &app: appList) {
const QVector<DesktopAppData>& appList = m_appsMap[cat];
for (const DesktopAppData& app : appList) {
if (!apps.contains(app) && (app.name.contains(regexp) ||
app.description.contains(regexp) ))
{
app.description.contains(regexp))) {
apps.append(app);
}
}
@@ -154,54 +164,58 @@ void AppLauncherWidget::searchChanged(const QString &text) {
}
}
void AppLauncherWidget::initListWidget() {
void AppLauncherWidget::initListWidget()
{
m_tabWidget = new QTabWidget;
const int size = GlobalValues::buttonBaseSize();
m_tabWidget->setIconSize(QSize(size, size));
for (auto const& i : catIconNames.toStdMap()) {
const QString &cat = i.first;
const QString &iconName = i.second;
const QString& cat = i.first;
const QString& iconName = i.second;
if (!m_appsMap.contains(cat)) {
continue;
}
QListWidget *itemsWidget = new QListWidget();
QListWidget* itemsWidget = new QListWidget();
configureListView(itemsWidget);
const QVector<DesktopAppData> &appList = m_appsMap[cat];
const QVector<DesktopAppData>& appList = m_appsMap[cat];
addAppsToListWidget(itemsWidget, appList);
m_tabWidget->addTab(itemsWidget, QIcon::fromTheme(iconName), QLatin1String(""));
m_tabWidget->addTab(
itemsWidget, QIcon::fromTheme(iconName), QLatin1String(""));
m_tabWidget->setTabToolTip(m_tabWidget->count(), cat);
if (cat == QLatin1String("Graphics")) {
m_tabWidget->setCurrentIndex(m_tabWidget->count() -1);
m_tabWidget->setCurrentIndex(m_tabWidget->count() - 1);
}
}
}
void AppLauncherWidget::initAppMap() {
QStringList categories({"AudioVideo",
"Audio",
"Video",
"Development",
"Graphics",
"Network",
"Office",
"Science",
"Settings",
"System",
"Utility"});
void AppLauncherWidget::initAppMap()
{
QStringList categories({ "AudioVideo",
"Audio",
"Video",
"Development",
"Graphics",
"Network",
"Office",
"Science",
"Settings",
"System",
"Utility" });
m_appsMap = m_parser.getAppsByCategory(categories);
// Unify multimedia.
QVector<DesktopAppData> multimediaList;
QStringList multimediaNames;
multimediaNames << QStringLiteral("AudioVideo") << QStringLiteral("Audio") << QStringLiteral("Video");
for (const QString &name : multimediaNames) {
if(!m_appsMap.contains(name)) {
multimediaNames << QStringLiteral("AudioVideo") << QStringLiteral("Audio")
<< QStringLiteral("Video");
for (const QString& name : multimediaNames) {
if (!m_appsMap.contains(name)) {
continue;
}
for (auto i : m_appsMap[name]) {
@@ -214,7 +228,8 @@ void AppLauncherWidget::initAppMap() {
m_appsMap.insert(QStringLiteral("Multimedia"), multimediaList);
}
void AppLauncherWidget::configureListView(QListWidget *widget) {
void AppLauncherWidget::configureListView(QListWidget* widget)
{
widget->setItemDelegate(new LauncherItemDelegate());
widget->setViewMode(QListWidget::IconMode);
widget->setResizeMode(QListView::Adjust);
@@ -222,21 +237,21 @@ void AppLauncherWidget::configureListView(QListWidget *widget) {
widget->setFlow(QListView::LeftToRight);
widget->setDragEnabled(false);
widget->setMinimumWidth(GlobalValues::buttonBaseSize() * 11);
connect(widget, &QListWidget::clicked,
this, &AppLauncherWidget::launch);
connect(widget, &QListWidget::clicked, this, &AppLauncherWidget::launch);
}
void AppLauncherWidget::addAppsToListWidget(
QListWidget *widget, const QVector<DesktopAppData> &appList)
QListWidget* widget,
const QVector<DesktopAppData>& appList)
{
for (const DesktopAppData &app: appList) {
QListWidgetItem *buttonItem = new QListWidgetItem(widget);
for (const DesktopAppData& app : appList) {
QListWidgetItem* buttonItem = new QListWidgetItem(widget);
buttonItem->setData(Qt::DecorationRole, app.icon);
buttonItem->setData(Qt::DisplayRole, app.name);
buttonItem->setData(Qt::UserRole, app.exec);
buttonItem->setData(Qt::UserRole+1, app.showInTerminal);
buttonItem->setData(Qt::UserRole + 1, app.showInTerminal);
QColor foregroundColor =
this->palette().color(QWidget::foregroundRole());
this->palette().color(QWidget::foregroundRole());
buttonItem->setForeground(foregroundColor);
buttonItem->setIcon(app.icon);

29
src/tools/launcher/applauncherwidget.h
View File

@@ -18,8 +18,8 @@
#pragma once
#include "src/utils/desktopfileparse.h"
#include <QWidget>
#include <QMap>
#include <QWidget>
class QTabWidget;
class QCheckBox;
@@ -27,32 +27,33 @@ class QVBoxLayout;
class QLineEdit;
class QListWidget;
class AppLauncherWidget: public QWidget {
class AppLauncherWidget : public QWidget
{
Q_OBJECT
public:
explicit AppLauncherWidget(const QPixmap &p, QWidget *parent = nullptr);
explicit AppLauncherWidget(const QPixmap& p, QWidget* parent = nullptr);
private slots:
void launch(const QModelIndex &index);
void launch(const QModelIndex& index);
void checkboxClicked(const bool enabled);
void searchChanged(const QString &text);
void searchChanged(const QString& text);
private:
void initListWidget();
void initAppMap();
void configureListView(QListWidget *widget);
void addAppsToListWidget(QListWidget *widget,
const QVector<DesktopAppData> &appList);
void configureListView(QListWidget* widget);
void addAppsToListWidget(QListWidget* widget,
const QVector<DesktopAppData>& appList);
DesktopFileParser m_parser;
QPixmap m_pixmap;
QString m_tempFile;
bool m_keepOpen;
QMap<QString, QVector<DesktopAppData>> m_appsMap;
QCheckBox *m_keepOpenCheckbox;
QCheckBox *m_terminalCheckbox;
QVBoxLayout *m_layout;
QLineEdit *m_lineEdit;
QListWidget *m_filterList;
QTabWidget *m_tabWidget;
QCheckBox* m_keepOpenCheckbox;
QCheckBox* m_terminalCheckbox;
QVBoxLayout* m_layout;
QLineEdit* m_lineEdit;
QListWidget* m_filterList;
QTabWidget* m_tabWidget;
};

44
src/tools/launcher/launcheritemdelegate.cpp
View File

@@ -19,45 +19,45 @@
#include "src/utils/globalvalues.h"
#include <QPainter>
LauncherItemDelegate::LauncherItemDelegate(QObject *parent) :
QStyledItemDelegate(parent)
{
}
LauncherItemDelegate::LauncherItemDelegate(QObject* parent)
: QStyledItemDelegate(parent)
{}
void LauncherItemDelegate::paint(
QPainter *painter,
const QStyleOptionViewItem &option,
const QModelIndex &index) const
void LauncherItemDelegate::paint(QPainter* painter,
const QStyleOptionViewItem& option,
const QModelIndex& index) const
{
const QRect &rect = option.rect;
const QRect& rect = option.rect;
if (option.state & (QStyle::State_Selected | QStyle::State_MouseOver)) {
painter->save();
painter->setPen(Qt::transparent);
painter->setBrush(QPalette().highlight());
painter->drawRect(rect.x(), rect.y(),
rect.width() -1, rect.height() -1);
painter->drawRect(
rect.x(), rect.y(), rect.width() - 1, rect.height() - 1);
painter->restore();
}
QIcon icon = index.data(Qt::DecorationRole).value<QIcon>();
const int iconSide = GlobalValues::buttonBaseSize() * 1.3;
const int halfIcon = iconSide/2;
const int halfWidth = rect.width()/2;
const int halfHeight = rect.height()/2;
const int halfIcon = iconSide / 2;
const int halfWidth = rect.width() / 2;
const int halfHeight = rect.height() / 2;
QSize size(iconSide, iconSide);
QPixmap pixIcon = icon.pixmap(size).scaled(size, Qt::KeepAspectRatio);
painter->drawPixmap(rect.x() + (halfWidth - halfIcon),
rect.y()+ (halfHeight/2 - halfIcon),
iconSide, iconSide, pixIcon);
const QRect textRect(rect.x(), rect.y() + halfHeight,
rect.width(), halfHeight);
painter->drawText(textRect, Qt::TextWordWrap | Qt::AlignHCenter,
rect.y() + (halfHeight / 2 - halfIcon),
iconSide,
iconSide,
pixIcon);
const QRect textRect(
rect.x(), rect.y() + halfHeight, rect.width(), halfHeight);
painter->drawText(textRect,
Qt::TextWordWrap | Qt::AlignHCenter,
index.data(Qt::DisplayRole).toString());
}
QSize LauncherItemDelegate::sizeHint(
const QStyleOptionViewItem &option,
const QModelIndex &index) const
QSize LauncherItemDelegate::sizeHint(const QStyleOptionViewItem& option,
const QModelIndex& index) const
{
Q_UNUSED(option);
Q_UNUSED(index);

14
src/tools/launcher/launcheritemdelegate.h
View File

@@ -20,14 +20,16 @@
#include "src/utils/desktopfileparse.h"
#include <QStyledItemDelegate>
class LauncherItemDelegate : public QStyledItemDelegate {
class LauncherItemDelegate : public QStyledItemDelegate
{
Q_OBJECT
public:
explicit LauncherItemDelegate(QObject *parent = nullptr);
explicit LauncherItemDelegate(QObject* parent = nullptr);
void paint(QPainter *painter,
const QStyleOptionViewItem &option,
const QModelIndex &index) const;
void paint(QPainter* painter,
const QStyleOptionViewItem& option,
const QModelIndex& index) const;
QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const;
QSize sizeHint(const QStyleOptionViewItem& option,
const QModelIndex& index) const;
};

14
src/tools/launcher/openwithprogram.cpp
View File

@@ -15,29 +15,31 @@
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "openwithprogram.h"
#if defined(Q_OS_WIN)
#include "src/utils/filenamehandler.h"
#include <QDir>
#include <QMessageBox>
#include <windows.h>
#include <Shlobj.h>
#include <windows.h>
#pragma comment(lib, "Shell32.lib")
#else
#include "src/tools/launcher/applauncherwidget.h"
#endif
void showOpenWithMenu(const QPixmap &capture) {
void showOpenWithMenu(const QPixmap& capture)
{
#if defined(Q_OS_WIN)
QString tempFile =
FileNameHandler().generateAbsolutePath(QDir::tempPath()) + ".png";
FileNameHandler().generateAbsolutePath(QDir::tempPath()) + ".png";
bool ok = capture.save(tempFile);
if (!ok) {
QMessageBox::about(nullptr, QObject::tr("Error"),
QObject::tr("Unable to write in") + QDir::tempPath());
QMessageBox::about(nullptr,
QObject::tr("Error"),
QObject::tr("Unable to write in") +
QDir::tempPath());
return;
}

2
src/tools/launcher/openwithprogram.h
View File

@@ -19,4 +19,4 @@
#include <QPixmap>
void showOpenWithMenu(const QPixmap &capture);
void showOpenWithMenu(const QPixmap& capture);

45
src/tools/launcher/terminallauncher.cpp
View File

@@ -16,34 +16,36 @@
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "terminallauncher.h"
#include <QProcess>
#include <QDir>
#include <QStandardPaths>
#include <QProcess>
#include <QProcessEnvironment>
#include <QStandardPaths>
namespace {
static const TerminalApp terminalApps[] = {
{ "x-terminal-emulator", "-e" },
{ "xfce4-terminal", "-x" },
{ "konsole", "-e" },
{ "gnome-terminal", "--" },
{ "terminator", "-e" },
{ "terminology", "-e" },
{ "tilix", "-e" },
{ "xterm", "-e" },
{ "aterm", "-e" },
{ "Eterm", "-e" },
{ "rxvt", "-e" },
{ "urxvt", "-e" },
};
static const TerminalApp terminalApps[] = {
{ "x-terminal-emulator", "-e" },
{ "xfce4-terminal", "-x" },
{ "konsole", "-e" },
{ "gnome-terminal", "--" },
{ "terminator", "-e" },
{ "terminology", "-e" },
{ "tilix", "-e" },
{ "xterm", "-e" },
{ "aterm", "-e" },
{ "Eterm", "-e" },
{ "rxvt", "-e" },
{ "urxvt", "-e" },
};
}
TerminalLauncher::TerminalLauncher(QObject *parent) : QObject(parent) {
}
TerminalLauncher::TerminalLauncher(QObject* parent)
: QObject(parent)
{}
TerminalApp TerminalLauncher::getPreferedTerminal() {
TerminalApp TerminalLauncher::getPreferedTerminal()
{
TerminalApp res;
for (const TerminalApp &app : terminalApps) {
for (const TerminalApp& app : terminalApps) {
QString path = QStandardPaths::findExecutable(app.name);
if (!path.isEmpty()) {
res = app;
@@ -53,7 +55,8 @@ TerminalApp TerminalLauncher::getPreferedTerminal() {
return res;
}
bool TerminalLauncher::launchDetached(const QString &command) {
bool TerminalLauncher::launchDetached(const QString& command)
{
TerminalApp app = getPreferedTerminal();
QString s = app.name + " " + app.arg + " " + command;
return QProcess::startDetached(s);

11
src/tools/launcher/terminallauncher.h
View File

@@ -19,17 +19,20 @@
#include <QObject>
struct TerminalApp {
struct TerminalApp
{
QString name;
QString arg;
};
class TerminalLauncher : public QObject {
class TerminalLauncher : public QObject
{
Q_OBJECT
public:
explicit TerminalLauncher(QObject *parent = nullptr);
explicit TerminalLauncher(QObject* parent = nullptr);
static bool launchDetached(const QString& command);
static bool launchDetached(const QString &command);
private:
static TerminalApp getPreferedTerminal();
};

34
src/tools/line/linetool.cpp
View File

@@ -24,32 +24,42 @@ namespace {
}
LineTool::LineTool(QObject *parent) : AbstractTwoPointTool(parent) {
LineTool::LineTool(QObject* parent)
: AbstractTwoPointTool(parent)
{
m_supportsOrthogonalAdj = true;
m_supportsDiagonalAdj = true;
}
QIcon LineTool::icon(const QColor &background, bool inEditor) const {
QIcon LineTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "line.svg");
}
QString LineTool::name() const {
QString LineTool::name() const
{
return tr("Line");
}
QString LineTool::nameID() {
QString LineTool::nameID()
{
return QLatin1String("");
}
QString LineTool::description() const {
QString LineTool::description() const
{
return tr("Set the Line as the paint tool");
}
CaptureTool* LineTool::copy(QObject *parent) {
CaptureTool* LineTool::copy(QObject* parent)
{
return new LineTool(parent);
}
void LineTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void LineTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (recordUndo) {
updateBackup(pixmap);
}
@@ -57,18 +67,22 @@ void LineTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo
painter.drawLine(m_points.first, m_points.second);
}
void LineTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void LineTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
painter.setPen(QPen(context.color, PADDING_VALUE + context.thickness));
painter.drawLine(context.mousePos, context.mousePos);
}
void LineTool::drawStart(const CaptureContext &context) {
void LineTool::drawStart(const CaptureContext& context)
{
m_color = context.color;
m_thickness = context.thickness + PADDING_VALUE;
m_points.first = context.mousePos;
m_points.second = context.mousePos;
}
void LineTool::pressed(const CaptureContext &context) {
void LineTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}

21
src/tools/line/linetool.h
View File

@@ -19,22 +19,25 @@
#include "src/tools/abstracttwopointtool.h"
class LineTool : public AbstractTwoPointTool {
class LineTool : public AbstractTwoPointTool
{
Q_OBJECT
public:
explicit LineTool(QObject *parent = nullptr);
explicit LineTool(QObject* parent = nullptr);
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
};

37
src/tools/marker/markertool.cpp
View File

@@ -24,32 +24,42 @@ namespace {
}
MarkerTool::MarkerTool(QObject *parent) : AbstractTwoPointTool(parent) {
MarkerTool::MarkerTool(QObject* parent)
: AbstractTwoPointTool(parent)
{
m_supportsOrthogonalAdj = true;
m_supportsDiagonalAdj = true;
}
QIcon MarkerTool::icon(const QColor &background, bool inEditor) const {
QIcon MarkerTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "marker.svg");
}
QString MarkerTool::name() const {
QString MarkerTool::name() const
{
return tr("Marker");
}
QString MarkerTool::nameID() {
QString MarkerTool::nameID()
{
return QLatin1String("");
}
QString MarkerTool::description() const {
QString MarkerTool::description() const
{
return tr("Set the Marker as the paint tool");
}
CaptureTool* MarkerTool::copy(QObject *parent) {
CaptureTool* MarkerTool::copy(QObject* parent)
{
return new MarkerTool(parent);
}
void MarkerTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void MarkerTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (recordUndo) {
updateBackup(pixmap);
}
@@ -59,24 +69,29 @@ void MarkerTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUn
painter.drawLine(m_points.first, m_points.second);
}
void MarkerTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void MarkerTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
painter.setCompositionMode(QPainter::CompositionMode_Multiply);
painter.setOpacity(0.35);
painter.setPen(QPen(context.color, PADDING_VALUE + context.thickness));
painter.drawLine(context.mousePos, context.mousePos);
}
void MarkerTool::drawStart(const CaptureContext &context) {
void MarkerTool::drawStart(const CaptureContext& context)
{
m_color = context.color;
m_thickness = context.thickness + PADDING_VALUE;
m_points.first = context.mousePos;
m_points.second = context.mousePos;
}
void MarkerTool::pressed(const CaptureContext &context) {
void MarkerTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}
void MarkerTool::thicknessChanged(const int th) {
void MarkerTool::thicknessChanged(const int th)
{
m_thickness = th + PADDING_VALUE;
}

21
src/tools/marker/markertool.h
View File

@@ -19,23 +19,26 @@
#include "src/tools/abstracttwopointtool.h"
class MarkerTool : public AbstractTwoPointTool {
class MarkerTool : public AbstractTwoPointTool
{
Q_OBJECT
public:
explicit MarkerTool(QObject *parent = nullptr);
explicit MarkerTool(QObject* parent = nullptr);
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
void thicknessChanged(const int th) override;
};

27
src/tools/move/movetool.cpp
View File

@@ -18,35 +18,42 @@
#include "movetool.h"
#include <QPainter>
MoveTool::MoveTool(QObject *parent) : AbstractActionTool(parent) {
MoveTool::MoveTool(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool MoveTool::closeOnButtonPressed() const {
bool MoveTool::closeOnButtonPressed() const
{
return false;
}
QIcon MoveTool::icon(const QColor &background, bool inEditor) const {
QIcon MoveTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "cursor-move.svg");
}
QString MoveTool::name() const {
QString MoveTool::name() const
{
return tr("Move");
}
QString MoveTool::nameID() {
QString MoveTool::nameID()
{
return QLatin1String("");
}
QString MoveTool::description() const {
QString MoveTool::description() const
{
return tr("Move the selection area");
}
CaptureTool* MoveTool::copy(QObject *parent) {
CaptureTool* MoveTool::copy(QObject* parent)
{
return new MoveTool(parent);
}
void MoveTool::pressed(const CaptureContext &context) {
void MoveTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
emit requestAction(REQ_MOVE_MODE);
}

11
src/tools/move/movetool.h
View File

@@ -19,20 +19,21 @@
#include "src/tools/abstractactiontool.h"
class MoveTool : public AbstractActionTool {
class MoveTool : public AbstractActionTool
{
Q_OBJECT
public:
explicit MoveTool(QObject *parent = nullptr);
explicit MoveTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
};

36
src/tools/pencil/penciltool.cpp
View File

@@ -18,31 +18,39 @@
#include "penciltool.h"
#include <QPainter>
PencilTool::PencilTool(QObject *parent) : AbstractPathTool(parent) {
PencilTool::PencilTool(QObject* parent)
: AbstractPathTool(parent)
{}
}
QIcon PencilTool::icon(const QColor &background, bool inEditor) const {
QIcon PencilTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "pencil.svg");
}
QString PencilTool::name() const {
QString PencilTool::name() const
{
return tr("Pencil");
}
QString PencilTool::nameID() {
QString PencilTool::nameID()
{
return QLatin1String("");
}
QString PencilTool::description() const {
QString PencilTool::description() const
{
return tr("Set the Pencil as the paint tool");
}
CaptureTool* PencilTool::copy(QObject *parent) {
CaptureTool* PencilTool::copy(QObject* parent)
{
return new PencilTool(parent);
}
void PencilTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void PencilTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (recordUndo) {
updateBackup(pixmap);
}
@@ -50,12 +58,15 @@ void PencilTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUn
painter.drawPolyline(m_points.data(), m_points.size());
}
void PencilTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void PencilTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
painter.setPen(QPen(context.color, context.thickness + 2));
painter.drawLine(context.mousePos, context.mousePos);
}
void PencilTool::drawStart(const CaptureContext &context) {
void PencilTool::drawStart(const CaptureContext& context)
{
m_color = context.color;
m_thickness = context.thickness + 2;
m_points.append(context.mousePos);
@@ -63,6 +74,7 @@ void PencilTool::drawStart(const CaptureContext &context) {
m_backupArea.setBottomRight(context.mousePos);
}
void PencilTool::pressed(const CaptureContext &context) {
void PencilTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}

21
src/tools/pencil/penciltool.h
View File

@@ -19,23 +19,26 @@
#include "src/tools/abstractpathtool.h"
class PencilTool : public AbstractPathTool {
class PencilTool : public AbstractPathTool
{
Q_OBJECT
public:
explicit PencilTool(QObject *parent = nullptr);
explicit PencilTool(QObject* parent = nullptr);
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
};

35
src/tools/pin/pintool.cpp
View File

@@ -18,47 +18,54 @@
#include "pintool.h"
#include "src/tools/pin/pinwidget.h"
PinTool::PinTool(QObject *parent) : AbstractActionTool(parent) {
PinTool::PinTool(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool PinTool::closeOnButtonPressed() const {
bool PinTool::closeOnButtonPressed() const
{
return true;
}
QIcon PinTool::icon(const QColor &background, bool inEditor) const {
QIcon PinTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "pin.svg");
}
QString PinTool::name() const {
QString PinTool::name() const
{
return tr("Pin Tool");
}
QString PinTool::nameID() {
QString PinTool::nameID()
{
return QLatin1String("");
}
QString PinTool::description() const {
QString PinTool::description() const
{
return tr("Pin image on the desktop");
}
QWidget* PinTool::widget() {
PinWidget *w = new PinWidget(m_pixmap);
const int &&m = w->margin();
QWidget* PinTool::widget()
{
PinWidget* w = new PinWidget(m_pixmap);
const int&& m = w->margin();
QRect adjusted_pos = m_geometry + QMargins(m, m, m, m);
w->setGeometry(adjusted_pos);
return w;
}
CaptureTool* PinTool::copy(QObject *parent) {
CaptureTool* PinTool::copy(QObject* parent)
{
return new PinTool(parent);
}
void PinTool::pressed(const CaptureContext &context) {
void PinTool::pressed(const CaptureContext& context)
{
emit requestAction(REQ_CAPTURE_DONE_OK);
m_geometry = context.selection;
m_geometry.setTopLeft(m_geometry.topLeft() + context.widgetOffset);
m_pixmap = context.selectedScreenshotArea();
emit requestAction(REQ_ADD_EXTERNAL_WIDGETS);
}

11
src/tools/pin/pintool.h Executable file → Normal file
View File

@@ -19,24 +19,25 @@
#include "src/tools/abstractactiontool.h"
class PinTool : public AbstractActionTool {
class PinTool : public AbstractActionTool
{
Q_OBJECT
public:
explicit PinTool(QObject *parent = nullptr);
explicit PinTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
QWidget* widget() override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
private:
QRect m_geometry;

47
src/tools/pin/pinwidget.cpp
View File

@@ -17,18 +17,18 @@
#include "pinwidget.h"
#include "src/utils/confighandler.h"
#include <QApplication>
#include <QLabel>
#include <QShortcut>
#include <QVBoxLayout>
#include <QWheelEvent>
#include <QApplication>
#include <QShortcut>
PinWidget::PinWidget(const QPixmap &pixmap, QWidget *parent) :
QWidget(parent), m_pixmap(pixmap)
PinWidget::PinWidget(const QPixmap& pixmap, QWidget* parent)
: QWidget(parent)
, m_pixmap(pixmap)
{
setWindowFlags(Qt::WindowStaysOnTopHint
| Qt::FramelessWindowHint);
//set the bottom widget background transparent
setWindowFlags(Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint);
// set the bottom widget background transparent
setAttribute(Qt::WA_TranslucentBackground);
ConfigHandler conf;
@@ -53,11 +53,13 @@ PinWidget::PinWidget(const QPixmap &pixmap, QWidget *parent) :
new QShortcut(Qt::Key_Escape, this, SLOT(close()));
}
int PinWidget::margin() const {
int PinWidget::margin() const
{
return 7;
}
void PinWidget::wheelEvent(QWheelEvent *e) {
void PinWidget::wheelEvent(QWheelEvent* e)
{
int val = e->delta() > 0 ? 15 : -15;
int newWidth = qBound(50, m_label->width() + val, maximumWidth());
int newHeight = qBound(50, m_label->height() + val, maximumHeight());
@@ -69,34 +71,41 @@ void PinWidget::wheelEvent(QWheelEvent *e) {
e->accept();
}
void PinWidget::enterEvent(QEvent *) {
void PinWidget::enterEvent(QEvent*)
{
m_shadowEffect->setColor(m_hoverColor);
}
void PinWidget::leaveEvent(QEvent *) {
void PinWidget::leaveEvent(QEvent*)
{
m_shadowEffect->setColor(m_baseColor);
}
void PinWidget::mouseDoubleClickEvent(QMouseEvent *) {
void PinWidget::mouseDoubleClickEvent(QMouseEvent*)
{
close();
}
void PinWidget::mousePressEvent(QMouseEvent *e) {
void PinWidget::mousePressEvent(QMouseEvent* e)
{
m_dragStart = e->globalPos();
m_offsetX = e->localPos().x() / width();
m_offsetX = e->localPos().x() / width();
m_offsetY = e->localPos().y() / height();
}
void PinWidget::mouseMoveEvent(QMouseEvent *e) {
void PinWidget::mouseMoveEvent(QMouseEvent* e)
{
const QPoint delta = e->globalPos() - m_dragStart;
int offsetW = width() * m_offsetX;
int offsetH = height() * m_offsetY;
move(m_dragStart.x() + delta.x() - offsetW, m_dragStart.y() + delta.y() - offsetH);
move(m_dragStart.x() + delta.x() - offsetW,
m_dragStart.y() + delta.y() - offsetH);
}
void PinWidget::setScaledPixmap(const QSize &size) {
void PinWidget::setScaledPixmap(const QSize& size)
{
const qreal scale = qApp->devicePixelRatio();
QPixmap scaledPixmap = m_pixmap.scaled(size * scale, Qt::KeepAspectRatio,
Qt::SmoothTransformation);
QPixmap scaledPixmap = m_pixmap.scaled(
size * scale, Qt::KeepAspectRatio, Qt::SmoothTransformation);
scaledPixmap.setDevicePixelRatio(scale);
m_label->setPixmap(scaledPixmap);
}

27
src/tools/pin/pinwidget.h
View File

@@ -17,35 +17,36 @@
#pragma once
#include <QWidget>
#include <QGraphicsDropShadowEffect>
#include <QWidget>
class QVBoxLayout;
class QLabel;
class PinWidget : public QWidget {
class PinWidget : public QWidget
{
Q_OBJECT
public:
explicit PinWidget(const QPixmap &pixmap, QWidget *parent = nullptr);
explicit PinWidget(const QPixmap& pixmap, QWidget* parent = nullptr);
int margin() const;
protected:
void wheelEvent(QWheelEvent *e);
void mouseDoubleClickEvent(QMouseEvent *);
void mousePressEvent(QMouseEvent *);
void mouseMoveEvent(QMouseEvent *);
void enterEvent(QEvent *);
void leaveEvent(QEvent *);
void wheelEvent(QWheelEvent* e);
void mouseDoubleClickEvent(QMouseEvent*);
void mousePressEvent(QMouseEvent*);
void mouseMoveEvent(QMouseEvent*);
void enterEvent(QEvent*);
void leaveEvent(QEvent*);
private:
void setScaledPixmap(const QSize &size);
void setScaledPixmap(const QSize& size);
QPixmap m_pixmap;
QVBoxLayout *m_layout;
QLabel *m_label;
QVBoxLayout* m_layout;
QLabel* m_label;
QPoint m_dragStart;
qreal m_offsetX, m_offsetY;
QGraphicsDropShadowEffect *m_shadowEffect;
QGraphicsDropShadowEffect* m_shadowEffect;
QColor m_baseColor, m_hoverColor;
};

34
src/tools/rectangle/rectangletool.cpp
View File

@@ -22,31 +22,41 @@ namespace {
#define PADDING_VALUE 2
}
RectangleTool::RectangleTool(QObject *parent) : AbstractTwoPointTool(parent) {
RectangleTool::RectangleTool(QObject* parent)
: AbstractTwoPointTool(parent)
{
m_supportsDiagonalAdj = true;
}
QIcon RectangleTool::icon(const QColor &background, bool inEditor) const {
QIcon RectangleTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "square.svg");
}
QString RectangleTool::name() const {
QString RectangleTool::name() const
{
return tr("Rectangle");
}
QString RectangleTool::nameID() {
QString RectangleTool::nameID()
{
return QLatin1String("");
}
QString RectangleTool::description() const {
QString RectangleTool::description() const
{
return tr("Set the Rectangle as the paint tool");
}
CaptureTool* RectangleTool::copy(QObject *parent) {
CaptureTool* RectangleTool::copy(QObject* parent)
{
return new RectangleTool(parent);
}
void RectangleTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void RectangleTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (recordUndo) {
updateBackup(pixmap);
}
@@ -55,18 +65,22 @@ void RectangleTool::process(QPainter &painter, const QPixmap &pixmap, bool recor
painter.drawRect(QRect(m_points.first, m_points.second));
}
void RectangleTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void RectangleTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
painter.setPen(QPen(context.color, PADDING_VALUE + context.thickness));
painter.drawLine(context.mousePos, context.mousePos);
}
void RectangleTool::drawStart(const CaptureContext &context) {
void RectangleTool::drawStart(const CaptureContext& context)
{
m_color = context.color;
m_thickness = context.thickness + PADDING_VALUE;
m_points.first = context.mousePos;
m_points.second = context.mousePos;
}
void RectangleTool::pressed(const CaptureContext &context) {
void RectangleTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}

21
src/tools/rectangle/rectangletool.h
View File

@@ -19,22 +19,25 @@
#include "src/tools/abstracttwopointtool.h"
class RectangleTool : public AbstractTwoPointTool {
class RectangleTool : public AbstractTwoPointTool
{
Q_OBJECT
public:
explicit RectangleTool(QObject *parent = nullptr);
explicit RectangleTool(QObject* parent = nullptr);
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
};

27
src/tools/redo/redotool.cpp
View File

@@ -18,35 +18,42 @@
#include "redotool.h"
#include <QPainter>
RedoTool::RedoTool(QObject *parent) : AbstractActionTool(parent) {
RedoTool::RedoTool(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool RedoTool::closeOnButtonPressed() const {
bool RedoTool::closeOnButtonPressed() const
{
return false;
}
QIcon RedoTool::icon(const QColor &background, bool inEditor) const {
QIcon RedoTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "redo-variant.svg");
}
QString RedoTool::name() const {
QString RedoTool::name() const
{
return tr("Redo");
}
QString RedoTool::nameID() {
QString RedoTool::nameID()
{
return QLatin1String("");
}
QString RedoTool::description() const {
QString RedoTool::description() const
{
return tr("Redo the next modification");
}
CaptureTool* RedoTool::copy(QObject *parent) {
CaptureTool* RedoTool::copy(QObject* parent)
{
return new RedoTool(parent);
}
void RedoTool::pressed(const CaptureContext &context) {
void RedoTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
emit requestAction(REQ_REDO_MODIFICATION);
}

12
src/tools/redo/redotool.h
View File

@@ -19,21 +19,21 @@
#include "src/tools/abstractactiontool.h"
class RedoTool : public AbstractActionTool {
class RedoTool : public AbstractActionTool
{
Q_OBJECT
public:
explicit RedoTool(QObject *parent = nullptr);
explicit RedoTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
};

31
src/tools/save/savetool.cpp
View File

@@ -19,45 +19,52 @@
#include "src/utils/screenshotsaver.h"
#include <QPainter>
SaveTool::SaveTool(QObject *parent) : AbstractActionTool(parent) {
SaveTool::SaveTool(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool SaveTool::closeOnButtonPressed() const {
bool SaveTool::closeOnButtonPressed() const
{
return true;
}
QIcon SaveTool::icon(const QColor &background, bool inEditor) const {
QIcon SaveTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "content-save.svg");
}
QString SaveTool::name() const {
QString SaveTool::name() const
{
return tr("Save");
}
QString SaveTool::nameID() {
QString SaveTool::nameID()
{
return QLatin1String("");
}
QString SaveTool::description() const {
QString SaveTool::description() const
{
return tr("Save the capture");
}
CaptureTool* SaveTool::copy(QObject *parent) {
CaptureTool* SaveTool::copy(QObject* parent)
{
return new SaveTool(parent);
}
void SaveTool::pressed(const CaptureContext &context) {
void SaveTool::pressed(const CaptureContext& context)
{
if (context.savePath.isEmpty()) {
emit requestAction(REQ_HIDE_GUI);
bool ok = ScreenshotSaver().saveToFilesystemGUI(
context.selectedScreenshotArea());
context.selectedScreenshotArea());
if (ok) {
emit requestAction(REQ_CAPTURE_DONE_OK);
}
} else {
bool ok = ScreenshotSaver().saveToFilesystem(
context.selectedScreenshotArea(), context.savePath);
context.selectedScreenshotArea(), context.savePath);
if (ok) {
emit requestAction(REQ_CAPTURE_DONE_OK);
}

11
src/tools/save/savetool.h
View File

@@ -19,20 +19,21 @@
#include "src/tools/abstractactiontool.h"
class SaveTool : public AbstractActionTool {
class SaveTool : public AbstractActionTool
{
Q_OBJECT
public:
explicit SaveTool(QObject *parent = nullptr);
explicit SaveTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
};

37
src/tools/selection/selectiontool.cpp
View File

@@ -22,35 +22,46 @@ namespace {
#define PADDING_VALUE 2
}
SelectionTool::SelectionTool(QObject *parent) : AbstractTwoPointTool(parent) {
SelectionTool::SelectionTool(QObject* parent)
: AbstractTwoPointTool(parent)
{
m_supportsDiagonalAdj = true;
}
bool SelectionTool::closeOnButtonPressed() const {
bool SelectionTool::closeOnButtonPressed() const
{
return false;
}
QIcon SelectionTool::icon(const QColor &background, bool inEditor) const {
QIcon SelectionTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "square-outline.svg");
}
QString SelectionTool::name() const {
QString SelectionTool::name() const
{
return tr("Rectangular Selection");
}
QString SelectionTool::nameID() {
QString SelectionTool::nameID()
{
return QLatin1String("");
}
QString SelectionTool::description() const {
QString SelectionTool::description() const
{
return tr("Set Selection as the paint tool");
}
CaptureTool* SelectionTool::copy(QObject *parent) {
CaptureTool* SelectionTool::copy(QObject* parent)
{
return new SelectionTool(parent);
}
void SelectionTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void SelectionTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (recordUndo) {
updateBackup(pixmap);
}
@@ -58,18 +69,22 @@ void SelectionTool::process(QPainter &painter, const QPixmap &pixmap, bool recor
painter.drawRect(QRect(m_points.first, m_points.second));
}
void SelectionTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void SelectionTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
painter.setPen(QPen(context.color, PADDING_VALUE + context.thickness));
painter.drawLine(context.mousePos, context.mousePos);
}
void SelectionTool::drawStart(const CaptureContext &context) {
void SelectionTool::drawStart(const CaptureContext& context)
{
m_color = context.color;
m_thickness = context.thickness + PADDING_VALUE;
m_points.first = context.mousePos;
m_points.second = context.mousePos;
}
void SelectionTool::pressed(const CaptureContext &context) {
void SelectionTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}

21
src/tools/selection/selectiontool.h
View File

@@ -19,24 +19,27 @@
#include "src/tools/abstracttwopointtool.h"
class SelectionTool : public AbstractTwoPointTool {
class SelectionTool : public AbstractTwoPointTool
{
Q_OBJECT
public:
explicit SelectionTool(QObject *parent = nullptr);
explicit SelectionTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
};

31
src/tools/sizeindicator/sizeindicatortool.cpp
View File

@@ -18,34 +18,41 @@
#include "sizeindicatortool.h"
#include <QPainter>
SizeIndicatorTool::SizeIndicatorTool(QObject *parent) : AbstractActionTool(parent) {
SizeIndicatorTool::SizeIndicatorTool(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool SizeIndicatorTool::closeOnButtonPressed() const {
bool SizeIndicatorTool::closeOnButtonPressed() const
{
return false;
}
QIcon SizeIndicatorTool::icon(const QColor &background, bool inEditor) const {
return inEditor ? QIcon() :
QIcon(iconPath(background) + "size_indicator.svg");
QIcon SizeIndicatorTool::icon(const QColor& background, bool inEditor) const
{
return inEditor ? QIcon()
: QIcon(iconPath(background) + "size_indicator.svg");
}
QString SizeIndicatorTool::name() const {
QString SizeIndicatorTool::name() const
{
return tr("Selection Size Indicator");
}
QString SizeIndicatorTool::nameID() {
QString SizeIndicatorTool::nameID()
{
return QLatin1String("");
}
QString SizeIndicatorTool::description() const {
QString SizeIndicatorTool::description() const
{
return tr("Show the dimensions of the selection (X Y)");
}
CaptureTool* SizeIndicatorTool::copy(QObject *parent) {
CaptureTool* SizeIndicatorTool::copy(QObject* parent)
{
return new SizeIndicatorTool(parent);
}
void SizeIndicatorTool::pressed(const CaptureContext &context) {
void SizeIndicatorTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}

11
src/tools/sizeindicator/sizeindicatortool.h
View File

@@ -19,20 +19,21 @@
#include "src/tools/abstractactiontool.h"
class SizeIndicatorTool : public AbstractActionTool {
class SizeIndicatorTool : public AbstractActionTool
{
Q_OBJECT
public:
explicit SizeIndicatorTool(QObject *parent = nullptr);
explicit SizeIndicatorTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
};

4
src/tools/storage/imguploader.cpp
View File

@@ -203,7 +203,7 @@ const QUrl& ImgUploader::imageUrl()
return m_imageURL;
}
void ImgUploader::showNotificationMessage(const QString& notificationMessage) {
void ImgUploader::showNotificationMessage(const QString& notificationMessage)
{
m_notification->showMessage(notificationMessage);
}

11
src/tools/storage/imguploadertool.cpp
View File

@@ -1,10 +1,8 @@
#include "imguploadertool.h"
ImgUploaderTool::ImgUploaderTool(QObject* parent)
: AbstractActionTool(parent)
{
}
: AbstractActionTool(parent)
{}
void ImgUploaderTool::setCapture(const QPixmap& pixmap)
{
@@ -18,7 +16,8 @@ void ImgUploaderTool::pressed(const CaptureContext& context)
emit requestAction(REQ_ADD_EXTERNAL_WIDGETS);
}
const QPixmap& ImgUploaderTool::capture() {
const QPixmap& ImgUploaderTool::capture()
{
return m_capture;
}
@@ -28,9 +27,7 @@ QIcon ImgUploaderTool::icon(const QColor& background, bool inEditor) const
return QIcon(iconPath(background) + "cloud-upload.svg");
}
bool ImgUploaderTool::closeOnButtonPressed() const
{
return true;
}

1
src/tools/storage/imguploadertool.h
View File

@@ -3,7 +3,6 @@
#include "src/tools/abstractactiontool.h"
class ImgUploaderTool : public AbstractActionTool
{
Q_OBJECT

5
src/tools/storage/storagemanager.cpp
View File

@@ -4,8 +4,8 @@
#include "imgur/imguruploadertool.h"
#include "s3/imgs3uploader.h"
#include "s3/imgs3uploadertool.h"
#include "src/tools/storage/s3/imgs3settings.h"
#include "src/tools/capturetool.h"
#include "src/tools/storage/s3/imgs3settings.h"
#include <QWidget>
@@ -22,7 +22,8 @@ CaptureTool* StorageManager::imgUploaderTool(const QString& imgUploaderType,
return nullptr;
}
const QString& StorageManager::storageUrl(const QString& imgUploaderType) {
const QString& StorageManager::storageUrl(const QString& imgUploaderType)
{
if (imgUploaderType == SCREENSHOT_STORAGE_TYPE_S3) {
ImgS3Settings s3Settings;
m_qstr = s3Settings.url();

2
src/tools/storage/storagemanager.h
View File

@@ -17,7 +17,7 @@ public:
QObject* parent = nullptr);
const QString& storageUrl(const QString& imgUploaderType);
// class members
// class members
private:
QString m_qstr;
};

75
src/tools/text/textconfig.cpp
View File

@@ -18,57 +18,69 @@
#include "textconfig.h"
#include "src/utils/colorutils.h"
#include "src/utils/pathinfo.h"
#include <QFontDatabase>
#include <QComboBox>
#include <QVBoxLayout>
#include <QFontDatabase>
#include <QHBoxLayout>
#include <QPushButton>
#include <QVBoxLayout>
TextConfig::TextConfig(QWidget *parent) : QWidget(parent) {
TextConfig::TextConfig(QWidget* parent)
: QWidget(parent)
{
m_layout = new QVBoxLayout(this);
QFontDatabase fontDB;
QComboBox *fontsCB = new QComboBox();
connect(fontsCB, &QComboBox::currentTextChanged,
this, &TextConfig::fontFamilyChanged);
QComboBox* fontsCB = new QComboBox();
connect(fontsCB,
&QComboBox::currentTextChanged,
this,
&TextConfig::fontFamilyChanged);
fontsCB->addItems(fontDB.families());
// TODO save family in config
int index = fontsCB->findText(font().family());
fontsCB->setCurrentIndex(index);
QColor bgColor(palette().background().color());
QString iconPrefix = ColorUtils::colorIsDark(bgColor) ?
PathInfo::whiteIconPath() :
PathInfo::blackIconPath();
QString iconPrefix = ColorUtils::colorIsDark(bgColor)
? PathInfo::whiteIconPath()
: PathInfo::blackIconPath();
m_strikeOutButton = new QPushButton(
QIcon(iconPrefix + "format_strikethrough.svg"), QLatin1String(""));
QIcon(iconPrefix + "format_strikethrough.svg"), QLatin1String(""));
m_strikeOutButton->setCheckable(true);
connect(m_strikeOutButton, &QPushButton::clicked,
this, &TextConfig::fontStrikeOutChanged);
connect(m_strikeOutButton,
&QPushButton::clicked,
this,
&TextConfig::fontStrikeOutChanged);
m_strikeOutButton->setToolTip(tr("StrikeOut"));
m_underlineButton = new QPushButton(
QIcon(iconPrefix + "format_underlined.svg"), QLatin1String(""));
QIcon(iconPrefix + "format_underlined.svg"), QLatin1String(""));
m_underlineButton->setCheckable(true);
connect(m_underlineButton, &QPushButton::clicked,
this, &TextConfig::fontUnderlineChanged);
connect(m_underlineButton,
&QPushButton::clicked,
this,
&TextConfig::fontUnderlineChanged);
m_underlineButton->setToolTip(tr("Underline"));
m_weightButton = new QPushButton(
QIcon(iconPrefix + "format_bold.svg"), QLatin1String(""));
m_weightButton =
new QPushButton(QIcon(iconPrefix + "format_bold.svg"), QLatin1String(""));
m_weightButton->setCheckable(true);
connect(m_weightButton, &QPushButton::clicked,
this, &TextConfig::weightButtonPressed);
connect(m_weightButton,
&QPushButton::clicked,
this,
&TextConfig::weightButtonPressed);
m_weightButton->setToolTip(tr("Bold"));
m_italicButton = new QPushButton(
QIcon(iconPrefix + "format_italic.svg"), QLatin1String(""));
m_italicButton = new QPushButton(QIcon(iconPrefix + "format_italic.svg"),
QLatin1String(""));
m_italicButton->setCheckable(true);
connect(m_italicButton, &QPushButton::clicked,
this, &TextConfig::fontItalicChanged);
connect(m_italicButton,
&QPushButton::clicked,
this,
&TextConfig::fontItalicChanged);
m_italicButton->setToolTip(tr("Italic"));
QHBoxLayout *modifiersLayout = new QHBoxLayout();
QHBoxLayout* modifiersLayout = new QHBoxLayout();
m_layout->addWidget(fontsCB);
modifiersLayout->addWidget(m_strikeOutButton);
@@ -78,23 +90,28 @@ TextConfig::TextConfig(QWidget *parent) : QWidget(parent) {
m_layout->addLayout(modifiersLayout);
}
void TextConfig::setUnderline(const bool u) {
void TextConfig::setUnderline(const bool u)
{
m_underlineButton->setChecked(u);
}
void TextConfig::setStrikeOut(const bool s) {
void TextConfig::setStrikeOut(const bool s)
{
m_strikeOutButton->setChecked(s);
}
void TextConfig::setWeight(const int w) {
void TextConfig::setWeight(const int w)
{
m_weightButton->setChecked(static_cast<QFont::Weight>(w) == QFont::Bold);
}
void TextConfig::setItalic(const bool i) {
void TextConfig::setItalic(const bool i)
{
m_italicButton->setChecked(i);
}
void TextConfig::weightButtonPressed(const bool w) {
void TextConfig::weightButtonPressed(const bool w)
{
if (w) {
emit fontWeightChanged(QFont::Bold);
} else {

17
src/tools/text/textconfig.h
View File

@@ -22,10 +22,11 @@
class QVBoxLayout;
class QPushButton;
class TextConfig : public QWidget {
class TextConfig : public QWidget
{
Q_OBJECT
public:
explicit TextConfig(QWidget *parent = nullptr);
explicit TextConfig(QWidget* parent = nullptr);
void setUnderline(const bool u);
void setStrikeOut(const bool s);
@@ -33,7 +34,7 @@ public:
void setItalic(const bool i);
signals:
void fontFamilyChanged(const QString &f);
void fontFamilyChanged(const QString& f);
void fontUnderlineChanged(const bool underlined);
void fontStrikeOutChanged(const bool dashed);
void fontWeightChanged(const QFont::Weight w);
@@ -45,9 +46,9 @@ private slots:
void weightButtonPressed(const bool w);
private:
QVBoxLayout *m_layout;
QPushButton *m_strikeOutButton;
QPushButton *m_underlineButton;
QPushButton *m_weightButton;
QPushButton *m_italicButton;
QVBoxLayout* m_layout;
QPushButton* m_strikeOutButton;
QPushButton* m_underlineButton;
QPushButton* m_weightButton;
QPushButton* m_italicButton;
};

152
src/tools/text/texttool.cpp
View File

@@ -16,71 +16,89 @@
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "texttool.h"
#include "textwidget.h"
#include "textconfig.h"
#include "textwidget.h"
#define BASE_POINT_SIZE 8
TextTool::TextTool(QObject* parent)
: CaptureTool(parent)
, m_size(1)
{}
TextTool::TextTool(QObject *parent) : CaptureTool(parent), m_size(1) {
}
bool TextTool::isValid() const {
bool TextTool::isValid() const
{
return !m_text.isEmpty();
}
bool TextTool::closeOnButtonPressed() const {
bool TextTool::closeOnButtonPressed() const
{
return false;
}
bool TextTool::isSelectable() const {
bool TextTool::isSelectable() const
{
return true;
}
bool TextTool::showMousePreview() const {
bool TextTool::showMousePreview() const
{
return false;
}
QIcon TextTool::icon(const QColor &background, bool inEditor) const {
QIcon TextTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "text.svg");
}
QString TextTool::name() const {
QString TextTool::name() const
{
return tr("Text");
}
QString TextTool::nameID() {
QString TextTool::nameID()
{
return QLatin1String("");
}
QString TextTool::description() const {
QString TextTool::description() const
{
return tr("Add text to your capture");
}
QWidget *TextTool::widget() {
TextWidget *w = new TextWidget();
QWidget* TextTool::widget()
{
TextWidget* w = new TextWidget();
w->setTextColor(m_color);
m_font.setPointSize(m_size + BASE_POINT_SIZE);
w->setFont(m_font);
connect(w, &TextWidget::textUpdated,
this, &TextTool::updateText);
connect(w, &TextWidget::textUpdated, this, &TextTool::updateText);
m_widget = w;
return w;
}
QWidget *TextTool::configurationWidget() {
QWidget* TextTool::configurationWidget()
{
m_confW = new TextConfig();
connect(m_confW, &TextConfig::fontFamilyChanged,
this, &TextTool::updateFamily);
connect(m_confW, &TextConfig::fontItalicChanged,
this, &TextTool::updateFontItalic);
connect(m_confW, &TextConfig::fontStrikeOutChanged,
this, &TextTool::updateFontStrikeOut);
connect(m_confW, &TextConfig::fontUnderlineChanged,
this, &TextTool::updateFontUnderline);
connect(m_confW, &TextConfig::fontWeightChanged,
this, &TextTool::updateFontWeight);
connect(
m_confW, &TextConfig::fontFamilyChanged, this, &TextTool::updateFamily);
connect(m_confW,
&TextConfig::fontItalicChanged,
this,
&TextTool::updateFontItalic);
connect(m_confW,
&TextConfig::fontStrikeOutChanged,
this,
&TextTool::updateFontStrikeOut);
connect(m_confW,
&TextConfig::fontUnderlineChanged,
this,
&TextTool::updateFontUnderline);
connect(m_confW,
&TextConfig::fontWeightChanged,
this,
&TextTool::updateFontWeight);
m_confW->setItalic(m_font.italic());
m_confW->setUnderline(m_font.underline());
m_confW->setStrikeOut(m_font.strikeOut());
@@ -88,28 +106,37 @@ QWidget *TextTool::configurationWidget() {
return m_confW;
}
CaptureTool *TextTool::copy(QObject *parent) {
TextTool *tt = new TextTool(parent);
connect(m_confW, &TextConfig::fontFamilyChanged,
tt, &TextTool::updateFamily);
connect(m_confW, &TextConfig::fontItalicChanged,
tt, &TextTool::updateFontItalic);
connect(m_confW, &TextConfig::fontStrikeOutChanged,
tt, &TextTool::updateFontStrikeOut);
connect(m_confW, &TextConfig::fontUnderlineChanged,
tt, &TextTool::updateFontUnderline);
connect(m_confW, &TextConfig::fontWeightChanged,
tt, &TextTool::updateFontWeight);
CaptureTool* TextTool::copy(QObject* parent)
{
TextTool* tt = new TextTool(parent);
connect(
m_confW, &TextConfig::fontFamilyChanged, tt, &TextTool::updateFamily);
connect(
m_confW, &TextConfig::fontItalicChanged, tt, &TextTool::updateFontItalic);
connect(m_confW,
&TextConfig::fontStrikeOutChanged,
tt,
&TextTool::updateFontStrikeOut);
connect(m_confW,
&TextConfig::fontUnderlineChanged,
tt,
&TextTool::updateFontUnderline);
connect(
m_confW, &TextConfig::fontWeightChanged, tt, &TextTool::updateFontWeight);
tt->m_font = m_font;
return tt;
}
void TextTool::undo(QPixmap &pixmap) {
void TextTool::undo(QPixmap& pixmap)
{
QPainter p(&pixmap);
p.drawPixmap(m_backupArea.topLeft(), m_pixmapBackup);
}
void TextTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo) {
void TextTool::process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo)
{
if (m_text.isEmpty()) {
return;
}
@@ -125,37 +152,45 @@ void TextTool::process(QPainter &painter, const QPixmap &pixmap, bool recordUndo
painter.drawText(m_backupArea + QMargins(-5, -5, 5, 5), m_text);
}
void TextTool::paintMousePreview(QPainter &painter, const CaptureContext &context) {
void TextTool::paintMousePreview(QPainter& painter,
const CaptureContext& context)
{
Q_UNUSED(painter);
Q_UNUSED(context);
}
void TextTool::drawEnd(const QPoint &p) {
void TextTool::drawEnd(const QPoint& p)
{
m_backupArea.moveTo(p);
}
void TextTool::drawMove(const QPoint &p) {
void TextTool::drawMove(const QPoint& p)
{
m_widget->move(p);
}
void TextTool::drawStart(const CaptureContext &context) {
void TextTool::drawStart(const CaptureContext& context)
{
m_color = context.color;
m_size = context.thickness;
emit requestAction(REQ_ADD_CHILD_WIDGET);
}
void TextTool::pressed(const CaptureContext &context) {
void TextTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
}
void TextTool::colorChanged(const QColor &c) {
void TextTool::colorChanged(const QColor& c)
{
m_color = c;
if (m_widget) {
m_widget->setTextColor(c);
}
}
void TextTool::thicknessChanged(const int th) {
void TextTool::thicknessChanged(const int th)
{
m_size = th;
m_font.setPointSize(m_size + BASE_POINT_SIZE);
if (m_widget) {
@@ -163,46 +198,53 @@ void TextTool::thicknessChanged(const int th) {
}
}
void TextTool::updateText(const QString &s) {
void TextTool::updateText(const QString& s)
{
m_text = s;
}
void TextTool::setFont(const QFont &f) {
void TextTool::setFont(const QFont& f)
{
m_font = f;
if (m_widget) {
m_widget->setFont(f);
}
}
void TextTool::updateFamily(const QString &s) {
void TextTool::updateFamily(const QString& s)
{
m_font.setFamily(s);
if (m_widget) {
m_widget->setFont(m_font);
}
}
void TextTool::updateFontUnderline(const bool underlined) {
void TextTool::updateFontUnderline(const bool underlined)
{
m_font.setUnderline(underlined);
if (m_widget) {
m_widget->setFont(m_font);
}
}
void TextTool::updateFontStrikeOut(const bool s) {
void TextTool::updateFontStrikeOut(const bool s)
{
m_font.setStrikeOut(s);
if (m_widget) {
m_widget->setFont(m_font);
}
}
void TextTool::updateFontWeight(const QFont::Weight w) {
void TextTool::updateFontWeight(const QFont::Weight w)
{
m_font.setWeight(w);
if (m_widget) {
m_widget->setFont(m_font);
}
}
void TextTool::updateFontItalic(const bool italic) {
void TextTool::updateFontItalic(const bool italic)
{
m_font.setItalic(italic);
if (m_widget) {
m_widget->setFont(m_font);

36
src/tools/text/texttool.h
View File

@@ -23,43 +23,45 @@
class TextWidget;
class TextConfig;
class TextTool : public CaptureTool {
class TextTool : public CaptureTool
{
Q_OBJECT
public:
explicit TextTool(QObject *parent = nullptr);
explicit TextTool(QObject* parent = nullptr);
bool isValid() const override;
bool closeOnButtonPressed() const override;
bool isSelectable() const override;
bool showMousePreview() const override;
QIcon icon(const QColor &background,
bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
QWidget* widget() override;
QWidget* configurationWidget() override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
void undo(QPixmap &pixmap) override;
void process(
QPainter &painter, const QPixmap &pixmap, bool recordUndo = false) override;
void paintMousePreview(QPainter &painter, const CaptureContext &context) override;
void undo(QPixmap& pixmap) override;
void process(QPainter& painter,
const QPixmap& pixmap,
bool recordUndo = false) override;
void paintMousePreview(QPainter& painter,
const CaptureContext& context) override;
public slots:
void drawEnd(const QPoint &p) override;
void drawMove(const QPoint &p) override;
void drawStart(const CaptureContext &context) override;
void pressed(const CaptureContext &context) override;
void colorChanged(const QColor &c) override;
void drawEnd(const QPoint& p) override;
void drawMove(const QPoint& p) override;
void drawStart(const CaptureContext& context) override;
void pressed(const CaptureContext& context) override;
void colorChanged(const QColor& c) override;
void thicknessChanged(const int th) override;
private slots:
void updateText(const QString &s);
void setFont(const QFont &f);
void updateFamily(const QString &s);
void updateText(const QString& s);
void setFont(const QFont& f);
void updateFamily(const QString& s);
void updateFontUnderline(const bool underlined);
void updateFontStrikeOut(const bool s);
void updateFontWeight(const QFont::Weight w);

41
src/tools/text/textwidget.cpp
View File

@@ -17,21 +17,22 @@
#include "textwidget.h"
TextWidget::TextWidget(QWidget *parent) : QTextEdit(parent) {
TextWidget::TextWidget(QWidget* parent)
: QTextEdit(parent)
{
setStyleSheet(QStringLiteral("TextWidget { background: transparent; }"));
connect(this, &TextWidget::textChanged,
this, &TextWidget::adjustSize);
connect(this, &TextWidget::textChanged,
this, &TextWidget::emitTextUpdated);
connect(this, &TextWidget::textChanged, this, &TextWidget::adjustSize);
connect(this, &TextWidget::textChanged, this, &TextWidget::emitTextUpdated);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setContextMenuPolicy(Qt::NoContextMenu);
}
void TextWidget::showEvent(QShowEvent *e) {
void TextWidget::showEvent(QShowEvent* e)
{
QFont font;
QFontMetrics fm(font);
setFixedWidth(fm.lineSpacing() *6);
setFixedWidth(fm.lineSpacing() * 6);
setFixedHeight(fm.lineSpacing() * 2.5);
m_baseSize = size();
m_minSize = m_baseSize;
@@ -39,34 +40,41 @@ void TextWidget::showEvent(QShowEvent *e) {
adjustSize();
}
void TextWidget::resizeEvent(QResizeEvent *e) {
void TextWidget::resizeEvent(QResizeEvent* e)
{
m_minSize.setHeight(qMin(m_baseSize.height(), height()));
m_minSize.setWidth(qMin(m_baseSize.width(), width()));
QTextEdit::resizeEvent(e);
}
void TextWidget::setFont(const QFont &f) {
void TextWidget::setFont(const QFont& f)
{
QTextEdit::setFont(f);
adjustSize();
}
void TextWidget::updateFont(const QFont &f) {
void TextWidget::updateFont(const QFont& f)
{
setFont(f);
}
void TextWidget::setFontPointSize(qreal s) {
void TextWidget::setFontPointSize(qreal s)
{
QFont f = font();
f.setPointSize(s);
setFont(f);
}
void TextWidget::setTextColor(const QColor &c) {
QString s(QStringLiteral("TextWidget { background: transparent; color: %1; }"));
void TextWidget::setTextColor(const QColor& c)
{
QString s(
QStringLiteral("TextWidget { background: transparent; color: %1; }"));
setStyleSheet(s.arg(c.name()));
}
void TextWidget::adjustSize() {
QString &&text = this->toPlainText();
void TextWidget::adjustSize()
{
QString&& text = this->toPlainText();
QFontMetrics fm(font());
QRect bounds = fm.boundingRect(QRect(), 0, text);
@@ -82,6 +90,7 @@ void TextWidget::adjustSize() {
this->setFixedSize(pixelsWide, pixelsHigh);
}
void TextWidget::emitTextUpdated() {
void TextWidget::emitTextUpdated()
{
emit textUpdated(this->toPlainText());
}

14
src/tools/text/textwidget.h
View File

@@ -23,21 +23,21 @@ class TextWidget : public QTextEdit
{
Q_OBJECT
public:
explicit TextWidget(QWidget *parent = nullptr);
explicit TextWidget(QWidget* parent = nullptr);
void adjustSize();
void setFont(const QFont &f);
void setFont(const QFont& f);
protected:
void showEvent(QShowEvent *e);
void resizeEvent(QResizeEvent *e);
void showEvent(QShowEvent* e);
void resizeEvent(QResizeEvent* e);
signals:
void textUpdated(const QString &s);
void textUpdated(const QString& s);
public slots:
void updateFont(const QFont &f);
void setTextColor(const QColor &c);
void updateFont(const QFont& f);
void setTextColor(const QColor& c);
void setFontPointSize(qreal s);
private slots:

17
src/tools/toolfactory.h
View File

@@ -17,23 +17,22 @@
#pragma once
#include "src/widgets/capture/capturebutton.h"
#include "src/tools/capturetool.h"
#include "src/widgets/capture/capturebutton.h"
#include <QObject>
class CaptureTool;
class ToolFactory : public QObject {
class ToolFactory : public QObject
{
Q_OBJECT
public:
explicit ToolFactory(QObject* parent = nullptr);
explicit ToolFactory(QObject *parent = nullptr);
ToolFactory(const ToolFactory&) = delete;
ToolFactory& operator=(const ToolFactory&) = delete;
ToolFactory(const ToolFactory &) = delete;
ToolFactory & operator=(const ToolFactory &) = delete;
CaptureTool* CreateTool(
CaptureButton::ButtonType t,
QObject *parent = nullptr);
CaptureTool* CreateTool(CaptureButton::ButtonType t,
QObject* parent = nullptr);
};

27
src/tools/undo/undotool.cpp
View File

@@ -18,35 +18,42 @@
#include "undotool.h"
#include <QPainter>
UndoTool::UndoTool(QObject *parent) : AbstractActionTool(parent) {
UndoTool::UndoTool(QObject* parent)
: AbstractActionTool(parent)
{}
}
bool UndoTool::closeOnButtonPressed() const {
bool UndoTool::closeOnButtonPressed() const
{
return false;
}
QIcon UndoTool::icon(const QColor &background, bool inEditor) const {
QIcon UndoTool::icon(const QColor& background, bool inEditor) const
{
Q_UNUSED(inEditor);
return QIcon(iconPath(background) + "undo-variant.svg");
}
QString UndoTool::name() const {
QString UndoTool::name() const
{
return tr("Undo");
}
QString UndoTool::nameID() {
QString UndoTool::nameID()
{
return QLatin1String("");
}
QString UndoTool::description() const {
QString UndoTool::description() const
{
return tr("Undo the last modification");
}
CaptureTool* UndoTool::copy(QObject *parent) {
CaptureTool* UndoTool::copy(QObject* parent)
{
return new UndoTool(parent);
}
void UndoTool::pressed(const CaptureContext &context) {
void UndoTool::pressed(const CaptureContext& context)
{
Q_UNUSED(context);
emit requestAction(REQ_UNDO_MODIFICATION);
}

12
src/tools/undo/undotool.h
View File

@@ -19,21 +19,21 @@
#include "src/tools/abstractactiontool.h"
class UndoTool : public AbstractActionTool {
class UndoTool : public AbstractActionTool
{
Q_OBJECT
public:
explicit UndoTool(QObject *parent = nullptr);
explicit UndoTool(QObject* parent = nullptr);
bool closeOnButtonPressed() const;
QIcon icon(const QColor &background, bool inEditor) const override;
QIcon icon(const QColor& background, bool inEditor) const override;
QString name() const override;
static QString nameID();
QString description() const override;
CaptureTool* copy(QObject *parent = nullptr) override;
CaptureTool* copy(QObject* parent = nullptr) override;
public slots:
void pressed(const CaptureContext &context) override;
void pressed(const CaptureContext& context) override;
};