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

Improve folder organization

Browse Source
This commit is contained in:
lupoDharkael
2018-01-30 15:23:44 +01:00
parent e0d70070bd
commit cc8f697163
28 changed files with 30 additions and 2297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
flameshot.pro
View File

@@ -66,13 +66,13 @@ include(src/third-party/Qt-Color-Widgets//color_widgets.pri)
DEFINES += QAPPLICATION_CLASS=QApplication
SOURCES += src/main.cpp \
src/capture/widget/buttonhandler.cpp \
src/capture/widgets/buttonhandler.cpp \
src/infowindow.cpp \
src/config/configwindow.cpp \
src/capture/screenshot.cpp \
src/capture/widget/capturewidget.cpp \
src/capture/widgets/capturewidget.cpp \
src/capture/capturemodification.cpp \
src/capture/widget/colorpicker.cpp \
src/capture/widgets/colorpicker.cpp \
src/config/buttonlistview.cpp \
src/config/uicoloreditor.cpp \
src/config/geneneralconf.cpp \
@@ -81,7 +81,7 @@ SOURCES += src/main.cpp \
src/config/filenameeditor.cpp \
src/config/strftimechooserwidget.cpp \
src/capture/tools/capturetool.cpp \
src/capture/widget/capturebutton.cpp \
src/capture/widgets/capturebutton.cpp \
src/capture/tools/penciltool.cpp \
src/capture/tools/undotool.cpp \
src/capture/tools/arrowtool.cpp \
@@ -106,11 +106,11 @@ SOURCES += src/main.cpp \
src/cli/commandargument.cpp \
src/capture/workers/screenshotsaver.cpp \
src/capture/workers/imgur/imguruploader.cpp \
src/capture/workers/imgur/loadspinner.cpp \
src/capture/workers/imgur/imagelabel.cpp \
src/capture/workers/imgur/notificationwidget.cpp \
src/widgets/loadspinner.cpp \
src/widgets/imagelabel.cpp \
src/widgets/notificationwidget.cpp \
src/core/resourceexporter.cpp \
src/capture/widget/notifierbox.cpp \
src/capture/widgets/notifierbox.cpp \
src/utils/desktopinfo.cpp \
src/capture/workers/launcher/applauncherwidget.cpp \
src/capture/tools/applauncher.cpp \
@@ -122,13 +122,13 @@ SOURCES += src/main.cpp \
src/config/extendedslider.cpp \
src/capture/workers/launcher/openwithprogram.cpp
HEADERS += src/capture/widget/buttonhandler.h \
HEADERS += src/capture/widgets/buttonhandler.h \
src/infowindow.h \
src/config/configwindow.h \
src/capture/screenshot.h \
src/capture/widget/capturewidget.h \
src/capture/widgets/capturewidget.h \
src/capture/capturemodification.h \
src/capture/widget/colorpicker.h \
src/capture/widgets/colorpicker.h \
src/config/buttonlistview.h \
src/config/uicoloreditor.h \
src/config/geneneralconf.h \
@@ -138,7 +138,7 @@ HEADERS += src/capture/widget/buttonhandler.h \
src/config/strftimechooserwidget.h \
src/utils/screengrabber.h \
src/capture/tools/capturetool.h \
src/capture/widget/capturebutton.h \
src/capture/widgets/capturebutton.h \
src/capture/tools/penciltool.h \
src/capture/tools/undotool.h \
src/capture/tools/arrowtool.h \
@@ -162,11 +162,11 @@ HEADERS += src/capture/widget/buttonhandler.h \
src/cli/commandargument.h \
src/capture/workers/screenshotsaver.h \
src/capture/workers/imgur/imguruploader.h \
src/capture/workers/imgur/loadspinner.h \
src/capture/workers/imgur/imagelabel.h \
src/capture/workers/imgur/notificationwidget.h \
src/widgets/loadspinner.h \
src/widgets/imagelabel.h \
src/widgets/notificationwidget.h \
src/core/resourceexporter.h \
src/capture/widget/notifierbox.h \
src/capture/widgets/notifierbox.h \
src/utils/desktopinfo.h \
src/capture/workers/launcher/applauncherwidget.h \
src/capture/tools/applauncher.h \

2
src/capture/capturemodification.h
View File

@@ -17,7 +17,7 @@
#pragma once
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include <QObject>
#include <QVector>

2
src/capture/screenshot.cpp
View File

@@ -16,7 +16,7 @@
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "src/capture/screenshot.h"
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include "capturemodification.h"
#include "src/capture/tools/capturetool.h"
#include "src/utils/filenamehandler.h"

2
src/capture/tools/toolfactory.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include <QObject>
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include "src/capture/tools/capturetool.h"
class CaptureTool;

375
src/capture/widget/buttonhandler.cpp
View File

@@ -1,375 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "buttonhandler.h"
#include <QPoint>
#include <QGuiApplication>
#include <QScreen>
// ButtonHandler is a habdler for every active button. It makes easier to
// manipulate the buttons as a unit.
ButtonHandler::ButtonHandler(const QVector<CaptureButton*> &v,
const QRect &limits, QObject *parent) :
QObject(parent), m_limits(limits)
{
setButtons(v);
init();
}
ButtonHandler::ButtonHandler(const QRect &limits, QObject *parent) :
QObject(parent), m_limits(limits)
{
init();
}
void ButtonHandler::hide() {
for (CaptureButton *b: m_vectorButtons)
b->hide();
}
void ButtonHandler::show() {
if (m_vectorButtons.isEmpty() || m_vectorButtons.first()->isVisible()) {
return;
}
for (CaptureButton *b: m_vectorButtons)
b->animatedShow();
}
bool ButtonHandler::isVisible() const {
bool ret = true;
for (const CaptureButton *b: m_vectorButtons) {
if (!b->isVisible()) {
ret = false;
break;
}
}
return ret;
}
bool ButtonHandler::buttonsAreInside() const {
return m_buttonsAreInside;
}
size_t ButtonHandler::size() const {
return m_vectorButtons.size();
}
// UpdatePosition updates the position of the buttons around the
// selection area. Ignores the sides blocked by the end of the screen.
// When the selection is too small it works on a virtual selection with
// the original in the center.
void ButtonHandler::updatePosition(const QRect &selection) {
resetRegionTrack();
const int vecLength = m_vectorButtons.size();
if (vecLength == 0) {
return;
}
// Copy of the selection area for internal modifications
m_selection = selection;
updateBlockedSides();
ensureSelectionMinimunSize();
// Indicates the actual button to be moved
int elemIndicator = 0;
while (elemIndicator < vecLength) {
// Add them inside the area when there is no more space
if (m_allSidesBlocked) {
positionButtonsInside(elemIndicator);
break; // the while
}
// Number of buttons per row column
int buttonsPerRow = (m_selection.width() + m_separator) / (m_buttonExtendedSize);
int buttonsPerCol = (m_selection.height() + m_separator) / (m_buttonExtendedSize);
// Buttons to be placed in the corners
int extraButtons = (vecLength - elemIndicator) -
(buttonsPerRow + buttonsPerCol) * 2;
int elemsAtCorners = extraButtons > 4 ? 4 : extraButtons;
int maxExtra = 2;
if (m_oneHorizontalBlocked) {
maxExtra = 1;
} else if (m_horizontalyBlocked) {
maxExtra = 0;
}
int elemCornersTop = qBound(0, elemsAtCorners, maxExtra);
elemsAtCorners -= elemCornersTop;
int elemCornersBotton = qBound(0, elemsAtCorners, maxExtra);
// Add buttons at the botton of the seletion
if (!m_blockedBotton) {
int addCounter = buttonsPerRow + elemCornersBotton;
// Don't add more than we have
addCounter = qBound(0, addCounter, vecLength - elemIndicator);
QPoint center = QPoint(m_selection.center().x(),
m_selection.bottom() + m_separator);
if (addCounter > buttonsPerRow) {
adjustHorizontalCenter(center);
}
// ElemIndicator, elemsAtCorners
QVector<QPoint> positions = horizontalPoints(center, addCounter, true);
moveButtonsToPoints(positions, elemIndicator);
}
// Add buttons at the right side of the seletion
if (!m_blockedRight && elemIndicator < vecLength) {
int addCounter = buttonsPerCol;
addCounter = qBound(0, addCounter, vecLength - elemIndicator);
QPoint center = QPoint(m_selection.right() + m_separator,
m_selection.center().y());
QVector<QPoint> positions = verticalPoints(center, addCounter, false);
moveButtonsToPoints(positions, elemIndicator);
}
// Add buttons at the top of the seletion
if (!m_blockedTop && elemIndicator < vecLength) {
int addCounter = buttonsPerRow + elemCornersTop;
addCounter = qBound(0, addCounter, vecLength - elemIndicator);
QPoint center = QPoint(m_selection.center().x(),
m_selection.top() - m_buttonExtendedSize);
if (addCounter == 1 + buttonsPerRow) {
adjustHorizontalCenter(center);
}
QVector<QPoint> positions = horizontalPoints(center, addCounter, false);
moveButtonsToPoints(positions, elemIndicator);
}
// Add buttons at the left side of the seletion
if (!m_blockedLeft && elemIndicator < vecLength) {
int addCounter = buttonsPerCol;
addCounter = qBound(0, addCounter, vecLength - elemIndicator);
QPoint center = QPoint(m_selection.left() - m_buttonExtendedSize,
m_selection.center().y());
QVector<QPoint> positions = verticalPoints(center, addCounter, true);
moveButtonsToPoints(positions, elemIndicator);
}
// If there are elements for the next cycle, increase the size of the
// base area
if (elemIndicator < vecLength && !(m_allSidesBlocked)) {
expandSelection();
}
updateBlockedSides();
}
}
// GetHPoints is an auxiliar method for the button position computation.
// starts from a known center and keeps adding elements horizontally
// and returns the computed positions.
QVector<QPoint> ButtonHandler::horizontalPoints(
const QPoint &center, const int elements, const bool leftToRight) const
{
QVector<QPoint> res;
// Distance from the center to start adding buttons
int shift = 0;
if (elements % 2 == 0) {
shift = m_buttonExtendedSize * (elements / 2) - (m_separator / 2);
} else {
shift = m_buttonExtendedSize * ((elements-1) / 2) + m_buttonBaseSize / 2;
}
if (!leftToRight) { shift -= m_buttonBaseSize; }
int x = leftToRight ? center.x() - shift :
center.x() + shift;
QPoint i(x, center.y());
while (elements > res.length()) {
res.append(i);
leftToRight ? i.setX(i.x() + m_buttonExtendedSize) :
i.setX(i.x() - m_buttonExtendedSize);
}
return res;
}
// getHPoints is an auxiliar method for the button position computation.
// starts from a known center and keeps adding elements vertically
// and returns the computed positions.
QVector<QPoint> ButtonHandler::verticalPoints(
const QPoint &center, const int elements, const bool upToDown) const
{
QVector<QPoint> res;
// Distance from the center to start adding buttons
int shift = 0;
if (elements % 2 == 0) {
shift = m_buttonExtendedSize * (elements / 2) - (m_separator / 2);
} else {
shift = m_buttonExtendedSize * ((elements-1) / 2) + m_buttonBaseSize / 2;
}
if (!upToDown) { shift -= m_buttonBaseSize; }
int y = upToDown ? center.y() - shift :
center.y() + shift;
QPoint i(center.x(), y);
while (elements > res.length()) {
res.append(i);
upToDown ? i.setY(i.y() + m_buttonExtendedSize) :
i.setY(i.y() - m_buttonExtendedSize);
}
return res;
}
void ButtonHandler::init() {
updateScreenRegions();
m_separator = CaptureButton::buttonBaseSize() / 4;
}
void ButtonHandler::resetRegionTrack() {
m_buttonsAreInside = false;
}
void ButtonHandler::updateBlockedSides() {
const int EXTENSION = m_separator * 2 + m_buttonBaseSize;
// Right
QPoint pointA(m_selection.right() + EXTENSION,
m_selection.bottom());
QPoint pointB(pointA.x(),
m_selection.top());
m_blockedRight = !(m_screenRegions.contains(pointA) &&
m_screenRegions.contains(pointB));
// Left
pointA.setX(m_selection.left() - EXTENSION);
pointB.setX(pointA.x());
m_blockedLeft = !(m_screenRegions.contains(pointA) &&
m_screenRegions.contains(pointB));
// Botton
pointA = QPoint(m_selection.left(),
m_selection.bottom() + EXTENSION);
pointB = QPoint(m_selection.right(),
pointA.y());
m_blockedBotton = !(m_screenRegions.contains(pointA) &&
m_screenRegions.contains(pointB));
// Top
pointA.setY(m_selection.top() - EXTENSION);
pointB.setY(pointA.y());
m_blockedTop = !(m_screenRegions.contains(pointA) &&
m_screenRegions.contains(pointB));
// Auxiliar
m_oneHorizontalBlocked = (!m_blockedRight && m_blockedLeft) ||
(m_blockedRight && !m_blockedLeft);
m_horizontalyBlocked = (m_blockedRight && m_blockedLeft);
m_allSidesBlocked = (m_blockedBotton && m_horizontalyBlocked && m_blockedTop);
}
void ButtonHandler::expandSelection() {
if (m_blockedRight && !m_blockedLeft) {
m_selection.setX(m_selection.x() - m_buttonExtendedSize);
} else if (!m_blockedRight && !m_blockedLeft) {
m_selection.setX(m_selection.x() - m_buttonExtendedSize);
m_selection.setWidth(m_selection.width() + m_buttonExtendedSize);
} else {
m_selection.setWidth(m_selection.width() + m_buttonExtendedSize);
}
if (m_blockedBotton && !m_blockedTop) {
m_selection.setY(m_selection.y() - m_buttonExtendedSize);
} else if (!m_blockedTop && !m_blockedBotton) {
m_selection.setY(m_selection.y() - m_buttonExtendedSize);
m_selection.setHeight(m_selection.height() + m_buttonExtendedSize);
} else {
m_selection.setHeight(m_selection.height() + m_buttonExtendedSize);
}
}
void ButtonHandler::positionButtonsInside(int index) {
// Position the buttons from left to right starting at the botton
// left of the selection.
// The main screen has priority as the reference when its x,y botton
// left corner values are lower than the ones of the selection.
QRect mainArea = QGuiApplication::primaryScreen()->geometry();
int xPos = m_selection.left() + m_separator;
int yPos = m_selection.bottom() - m_buttonExtendedSize;
if (m_selection.left() < mainArea.left()) {
xPos = mainArea.left() + m_separator;
}
if (m_selection.bottom() > mainArea.bottom()) {
yPos = mainArea.bottom() - m_buttonExtendedSize;
}
CaptureButton *button = nullptr;
for (; index < m_vectorButtons.size(); ++index) {
button = m_vectorButtons[index];
button->move(xPos, yPos);
if (button->pos().x() + m_buttonExtendedSize > mainArea.right()) {
xPos = m_selection.left() + m_separator;
yPos -= (m_buttonExtendedSize);
}
xPos += (m_buttonExtendedSize);
}
m_buttonsAreInside = true;
}
void ButtonHandler::ensureSelectionMinimunSize() {
// Detect if a side is smaller than a button in order to prevent collision
// and redimension the base area the the base size of a single button per side
if (m_selection.width() < m_buttonBaseSize) {
if (!m_blockedLeft) {
m_selection.setX(m_selection.x() -
(m_buttonBaseSize-m_selection.width()) / 2);
}
m_selection.setWidth(m_buttonBaseSize);
}
if (m_selection.height() < m_buttonBaseSize) {
if (!m_blockedTop) {
m_selection.setY(m_selection.y() -
(m_buttonBaseSize-m_selection.height()) / 2);
}
m_selection.setHeight(m_buttonBaseSize);
}
}
void ButtonHandler::moveButtonsToPoints(
const QVector<QPoint> &points, int &index)
{
for (const QPoint &p: points) {
auto button = m_vectorButtons[index];
button->move(p);
++index;
}
}
void ButtonHandler::adjustHorizontalCenter(QPoint &center) {
if (m_blockedLeft) {
center.setX(center.x() + m_buttonExtendedSize/2);
} else if (m_blockedRight) {
center.setX(center.x() - m_buttonExtendedSize/2);
}
}
// setButtons redefines the buttons of the button handler
void ButtonHandler::setButtons(const QVector<CaptureButton *> v) {
if (v.isEmpty())
return;
for (CaptureButton *b: m_vectorButtons)
delete(b);
m_vectorButtons = v;
m_buttonBaseSize = CaptureButton::buttonBaseSize();
m_buttonExtendedSize = m_buttonBaseSize + m_separator;
}
bool ButtonHandler::contains(const QPoint &p) const {
QPoint first(m_vectorButtons.first()->pos());
QPoint last(m_vectorButtons.last()->pos());
bool firstIsTopLeft = (first.x() <= last.x() && first.y() <= last.y());
QPoint topLeft = firstIsTopLeft ? first : last;
QPoint bottonRight = firstIsTopLeft ? last : first;
topLeft += QPoint(-m_separator, -m_separator);
bottonRight += QPoint(m_buttonExtendedSize, m_buttonExtendedSize);
QRegion r(QRect(topLeft, bottonRight).normalized());
return r.contains(p);
}
void ButtonHandler::updateScreenRegions() {
m_screenRegions = QRegion();
for (QScreen *const screen : QGuiApplication::screens()) {
m_screenRegions += screen->geometry();
}
}

87
src/capture/widget/buttonhandler.h
View File

@@ -1,87 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "capturebutton.h"
#include <QVector>
#include <QObject>
#include <QRegion>
class CaptureButton;
class QRect;
class QPoint;
class ButtonHandler : public QObject {
Q_OBJECT
public:
ButtonHandler(const QVector<CaptureButton*>&, const QRect &limits, QObject *parent = nullptr);
ButtonHandler(const QRect &limits, QObject *parent = nullptr);
void hideSectionUnderMouse(const QPoint &p);
bool isVisible() const;
bool buttonsAreInside() const;
size_t size() const;
void updatePosition(const QRect &selection);
void setButtons(const QVector<CaptureButton*>);
bool contains(const QPoint &p) const;
void updateScreenRegions();
public slots:
void hide();
void show();
private:
QVector<QPoint> horizontalPoints(const QPoint &center, const int elements,
const bool leftToRight) const;
QVector<QPoint> verticalPoints(const QPoint &center, const int elements,
const bool upToDown) const;
QVector<CaptureButton*> m_vectorButtons;
QRegion m_screenRegions;
int m_buttonExtendedSize;
int m_buttonBaseSize;
bool m_buttonsAreInside;
bool m_blockedRight;
bool m_blockedLeft;
bool m_blockedBotton;
bool m_blockedTop;
bool m_oneHorizontalBlocked;
bool m_horizontalyBlocked;
bool m_allSidesBlocked;
QRect m_limits;
QRect m_selection;
int m_separator;
// aux methods
void init();
void resetRegionTrack();
void updateBlockedSides();
void expandSelection();
void positionButtonsInside(int index);
void ensureSelectionMinimunSize();
void moveButtonsToPoints(const QVector<QPoint> &points, int &index);
void adjustHorizontalCenter(QPoint &center);
};

223
src/capture/widget/capturebutton.cpp
View File

@@ -1,223 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "capturebutton.h"
#include "src/capture/widget/capturewidget.h"
#include "src/utils/confighandler.h"
#include "src/capture/tools/capturetool.h"
#include "src/capture/tools/toolfactory.h"
#include <QIcon>
#include <QPropertyAnimation>
#include <QToolTip>
#include <QMouseEvent>
#include <QGraphicsDropShadowEffect>
#include <QApplication>
// Button represents a single button of the capture widget, it can enable
// multiple functionality.
namespace {
qreal getColorLuma(const QColor &c) {
return 0.30 * c.redF() + 0.59 * c.greenF() + 0.11 * c.blueF();
}
QColor getContrastColor(const QColor &c) {
bool isWhite = CaptureButton::iconIsWhiteByColor(c);
int change = isWhite ? 30 : -45;
return QColor(qBound(0, c.red() + change, 255),
qBound(0, c.green() + change, 255),
qBound(0, c.blue() + change, 255));
}
} // unnamed namespace
CaptureButton::CaptureButton(const ButtonType t, QWidget *parent) : QPushButton(parent),
m_buttonType(t)
{
initButton();
if (t == TYPE_SELECTIONINDICATOR) {
QFont f = this->font();
setFont(QFont(f.family(), 7, QFont::Bold));
} else {
updateIcon();
}
setCursor(Qt::ArrowCursor);
}
void CaptureButton::initButton() {
m_tool = ToolFactory().CreateTool(m_buttonType, this);
connect(this, &CaptureButton::pressed, m_tool, &CaptureTool::onPressed);
setFocusPolicy(Qt::NoFocus);
resize(buttonBaseSize(), buttonBaseSize());
setMask(QRegion(QRect(-1,-1, buttonBaseSize()+2, buttonBaseSize()+2), QRegion::Ellipse));
setToolTip(m_tool->description());
m_emergeAnimation = new QPropertyAnimation(this, "size", this);
m_emergeAnimation->setEasingCurve(QEasingCurve::InOutQuad);
m_emergeAnimation->setDuration(80);
m_emergeAnimation->setStartValue(QSize(0, 0));
m_emergeAnimation->setEndValue(QSize(buttonBaseSize(), buttonBaseSize()));
auto dsEffect = new QGraphicsDropShadowEffect(this);
dsEffect->setBlurRadius(5);
dsEffect->setOffset(0);
dsEffect->setColor(QColor(Qt::black));
setGraphicsEffect(dsEffect);
}
void CaptureButton::updateIcon() {
setIcon(icon());
setIconSize(size()*0.6);
}
QVector<CaptureButton::ButtonType> CaptureButton::getIterableButtonTypes() {
return iterableButtonTypes;
}
QString CaptureButton::globalStyleSheet() {
QColor mainColor = ConfigHandler().uiMainColorValue();
QString baseSheet = "CaptureButton { border-radius: %3;"
"background-color: %1; color: %4 }"
"CaptureButton:hover { background-color: %2; }"
"CaptureButton:pressed:!hover { "
"background-color: %1; }";
// define color when mouse is hovering
QColor contrast = getContrastColor(m_mainColor);
// foreground color
QString color = iconIsWhiteByColor(mainColor) ? "white" : "black";
return baseSheet.arg(mainColor.name()).arg(contrast.name())
.arg(buttonBaseSize()/2).arg(color);
}
QString CaptureButton::styleSheet() const {
QString baseSheet = "CaptureButton { border-radius: %3;"
"background-color: %1; color: %4 }"
"CaptureButton:hover { background-color: %2; }"
"CaptureButton:pressed:!hover { "
"background-color: %1; }";
// define color when mouse is hovering
QColor contrast = getContrastColor(m_mainColor);
// foreground color
QString color = iconIsWhiteByColor(m_mainColor) ? "white" : "black";
return baseSheet.arg(m_mainColor.name()).arg(contrast.name())
.arg(buttonBaseSize()/2).arg(color);
}
// get icon returns the icon for the type of button
QIcon CaptureButton::icon() const {
QString color(iconIsWhiteByColor(m_mainColor) ? "White" : "Black");
QString iconPath = QStringLiteral(":/img/buttonIcons%1/%2")
.arg(color).arg(m_tool->iconName());
return QIcon(iconPath);
}
void CaptureButton::mousePressEvent(QMouseEvent *e) {
if (e->button() == Qt::LeftButton) {
Q_EMIT pressedButton(this);
Q_EMIT pressed();
}
}
void CaptureButton::animatedShow() {
if(!isVisible()) {
show();
m_emergeAnimation->start();
connect(m_emergeAnimation, &QPropertyAnimation::finished, this, [this](){
});
}
}
CaptureButton::ButtonType CaptureButton::buttonType() const {
return m_buttonType;
}
CaptureTool *CaptureButton::tool() const {
return m_tool;
}
void CaptureButton::setColor(const QColor &c) {
m_mainColor = c;
setStyleSheet(styleSheet());
updateIcon();
}
// getButtonBaseSize returns the base size of the buttons
int CaptureButton::buttonBaseSize() {
return QApplication::fontMetrics().lineSpacing() * 2.2;
}
bool CaptureButton::iconIsWhiteByColor(const QColor &c) {
bool isWhite = false;
if (getColorLuma(c) <= 0.60) {
isWhite = true;
}
return isWhite;
}
QColor CaptureButton::m_mainColor = ConfigHandler().uiMainColorValue();
static std::map<CaptureButton::ButtonType, int> buttonTypeOrder {
{ CaptureButton::TYPE_PENCIL, 0 },
{ CaptureButton::TYPE_LINE, 1 },
{ CaptureButton::TYPE_ARROW, 2 },
{ CaptureButton::TYPE_SELECTION, 3 },
{ CaptureButton::TYPE_RECTANGLE, 4 },
{ CaptureButton::TYPE_CIRCLE, 5 },
{ CaptureButton::TYPE_MARKER, 6 },
{ CaptureButton::TYPE_SELECTIONINDICATOR, 8 },
{ CaptureButton::TYPE_MOVESELECTION, 9 },
{ CaptureButton::TYPE_UNDO, 10 },
{ CaptureButton::TYPE_COPY, 11 },
{ CaptureButton::TYPE_SAVE, 12 },
{ CaptureButton::TYPE_EXIT, 13 },
{ CaptureButton::TYPE_IMAGEUPLOADER, 14 },
{ CaptureButton::TYPE_OPEN_APP, 15 },
{ CaptureButton::TYPE_BLUR, 7 },
};
int CaptureButton::getPriorityByButton(CaptureButton::ButtonType b) {
auto it = buttonTypeOrder.find(b);
return it == buttonTypeOrder.cend() ? (int)buttonTypeOrder.size() : it->second;
}
QVector<CaptureButton::ButtonType> CaptureButton::iterableButtonTypes = {
CaptureButton::TYPE_PENCIL,
CaptureButton::TYPE_LINE,
CaptureButton::TYPE_ARROW,
CaptureButton::TYPE_SELECTION,
CaptureButton::TYPE_RECTANGLE,
CaptureButton::TYPE_CIRCLE,
CaptureButton::TYPE_MARKER,
CaptureButton::TYPE_BLUR,
CaptureButton::TYPE_SELECTIONINDICATOR,
CaptureButton::TYPE_MOVESELECTION,
CaptureButton::TYPE_UNDO,
CaptureButton::TYPE_COPY,
CaptureButton::TYPE_SAVE,
CaptureButton::TYPE_EXIT,
CaptureButton::TYPE_IMAGEUPLOADER,
CaptureButton::TYPE_OPEN_APP,
};

93
src/capture/widget/capturebutton.h
View File

@@ -1,93 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <QPushButton>
#include <QMap>
#include <QVector>
class QWidget;
class QPropertyAnimation;
class CaptureTool;
class CaptureButton : public QPushButton {
Q_OBJECT
Q_ENUMS(ButtonType)
public:
// Don't forget to add the new types to CaptureButton::iterableButtonTypes
// in the .cpp and the order value in the private array buttonTypeOrder
enum ButtonType {
TYPE_PENCIL = 0,
TYPE_LINE = 1,
TYPE_ARROW = 2,
TYPE_SELECTION = 3,
TYPE_RECTANGLE = 4,
TYPE_CIRCLE = 5,
TYPE_MARKER = 6,
TYPE_SELECTIONINDICATOR = 7,
TYPE_MOVESELECTION = 8,
TYPE_UNDO = 9,
TYPE_COPY = 10,
TYPE_SAVE = 11,
TYPE_EXIT = 12,
TYPE_IMAGEUPLOADER = 13,
TYPE_OPEN_APP = 14,
TYPE_BLUR = 15,
};
CaptureButton() = delete;
explicit CaptureButton(const ButtonType, QWidget *parent = nullptr);
static int buttonBaseSize();
static bool iconIsWhiteByColor(const QColor &);
static QString globalStyleSheet();
static QVector<CaptureButton::ButtonType> getIterableButtonTypes();
static int getPriorityByButton(CaptureButton::ButtonType);
QString name() const;
QString description() const;
QIcon icon() const;
QString styleSheet() const;
ButtonType buttonType() const;
CaptureTool* tool() const;
void setColor(const QColor &c);
void animatedShow();
protected:
virtual void mousePressEvent(QMouseEvent *);
static QVector<ButtonType> iterableButtonTypes;
CaptureTool *m_tool;
signals:
void pressedButton(CaptureButton *);
private:
CaptureButton(QWidget *parent = 0);
ButtonType m_buttonType;
QPropertyAnimation *m_emergeAnimation;
static QColor m_mainColor;
void initButton();
void updateIcon();
};

675
src/capture/widget/capturewidget.cpp
View File

@@ -1,675 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
// Based on Lightscreen areadialog.cpp, Copyright 2017 Christian Kaiser <info@ckaiser.com.ar>
// released under the GNU GPL2 <https://www.gnu.org/licenses/gpl-2.0.txt>
// Based on KDE's KSnapshot regiongrabber.cpp, revision 796531, Copyright 2007 Luca Gugelmann <lucag@student.ethz.ch>
// released under the GNU LGPL <http://www.gnu.org/licenses/old-licenses/library.txt>
#include "src/capture/screenshot.h"
#include "src/capture/capturemodification.h"
#include "capturewidget.h"
#include "capturebutton.h"
#include "src/capture/widget/notifierbox.h"
#include "src/capture/widget/colorpicker.h"
#include "src/utils/screengrabber.h"
#include "src/utils/systemnotification.h"
#include "src/core/resourceexporter.h"
#include <QScreen>
#include <QGuiApplication>
#include <QApplication>
#include <QShortcut>
#include <QPainter>
#include <QPaintEvent>
#include <QMouseEvent>
#include <QBuffer>
// CaptureWidget is the main component used to capture the screen. It contains an
// are of selection with its respective buttons.
// enableSaveWIndow
CaptureWidget::CaptureWidget(const uint id, const QString &forcedSavePath,
QWidget *parent) :
QWidget(parent), m_screenshot(nullptr), m_mouseOverHandle(0),
m_mouseIsClicked(false), m_rightClick(false), m_newSelection(false),
m_grabbing(false), m_captureDone(false), m_toolIsForDrawing(false),
m_forcedSavePath(forcedSavePath), m_id(id),
m_state(CaptureButton::TYPE_MOVESELECTION)
{
m_showInitialMsg = m_config.showHelpValue();
m_thickness = m_config.drawThicknessValue();
m_opacity = m_config.contrastOpacityValue();
setAttribute(Qt::WA_DeleteOnClose);
// create selection handlers
QRect baseRect(0, 0, handleSize(), handleSize());
m_TLHandle = baseRect; m_TRHandle = baseRect;
m_BLHandle = baseRect; m_BRHandle = baseRect;
m_LHandle = baseRect; m_THandle = baseRect;
m_RHandle = baseRect; m_BHandle = baseRect;
m_handles << &m_TLHandle << &m_TRHandle << &m_BLHandle << &m_BRHandle
<< &m_LHandle << &m_THandle << &m_RHandle << &m_BHandle;
m_sides << &m_TLHandle << &m_TRHandle << &m_BLHandle << &m_BRHandle
<< &m_LSide << &m_TSide << &m_RSide << &m_BSide;
// set base config of the widget
#ifdef Q_OS_WIN
setWindowFlags(Qt::WindowStaysOnTopHint
| Qt::FramelessWindowHint
| Qt::Popup);
#else
setWindowFlags(Qt::BypassWindowManagerHint
| Qt::WindowStaysOnTopHint
| Qt::FramelessWindowHint
| Qt::Tool);
#endif
setMouseTracking(true);
updateCursor();
initShortcuts();
// init content
bool ok = true;
QPixmap fullScreenshot(ScreenGrabber().grabEntireDesktop(ok));
if(!ok) {
SystemNotification().sendMessage(tr("Unable to capture screen"));
this->close();
}
m_screenshot = new Screenshot(fullScreenshot, this);
QSize size = fullScreenshot.size();
// we need to increase by 1 the size to reach to the end of the screen
setGeometry(0 ,0 , size.width(), size.height());
// create buttons
m_buttonHandler = new ButtonHandler(rect(), this);
updateButtons();
m_buttonHandler->hide();
// init interface color
m_colorPicker = new ColorPicker(this);
m_colorPicker->hide();
m_notifierBox = new NotifierBox(this);
auto geometry = QGuiApplication::primaryScreen()->geometry();
m_notifierBox->move(geometry.left() +20, geometry.left() +20);
m_notifierBox->hide();
}
CaptureWidget::~CaptureWidget() {
if (m_captureDone) {
QByteArray byteArray;
QBuffer buffer(&byteArray);
this->pixmap().save(&buffer, "PNG");
Q_EMIT captureTaken(m_id, byteArray);
} else {
Q_EMIT captureFailed(m_id);
}
m_config.setdrawThickness(m_thickness);
}
// redefineButtons retrieves the buttons configured to be shown with the
// selection in the capture
void CaptureWidget::updateButtons() {
m_uiColor = m_config.uiMainColorValue();
m_contrastUiColor = m_config.uiContrastColorValue();
auto buttons = m_config.getButtons();
QVector<CaptureButton*> vectorButtons;
for (const CaptureButton::ButtonType &t: buttons) {
CaptureButton *b = new CaptureButton(t, this);
if (t == CaptureButton::TYPE_SELECTIONINDICATOR) {
m_sizeIndButton = b;
}
b->setColor(m_uiColor);
connect(b, &CaptureButton::pressedButton, this, &CaptureWidget::setState);
connect(b->tool(), &CaptureTool::requestAction,
this, &CaptureWidget::handleButtonSignal);
vectorButtons << b;
}
m_buttonHandler->setButtons(vectorButtons);
}
QPixmap CaptureWidget::pixmap() {
if (m_selection.isNull()) { // copy full screen when no selection
return m_screenshot->screenshot();
} else {
return m_screenshot->screenshot().copy(extendedSelection());
}
}
void CaptureWidget::paintEvent(QPaintEvent *) {
QPainter painter(this);
// If we are creating a new modification to the screenshot we just draw
// a temporal modification without antialiasing in the pencil tool for
// performance. When we are not drawing we just shot the modified screenshot
bool stateIsSelection = m_state == CaptureButton::TYPE_MOVESELECTION;
if (m_mouseIsClicked && !stateIsSelection) {
painter.drawPixmap(0, 0, m_screenshot->paintTemporalModification(
m_modifications.last()));
} else if (m_toolIsForDrawing && !stateIsSelection) {
CaptureButton::ButtonType type = CaptureButton::ButtonType::TYPE_LINE;
if (m_state == CaptureButton::ButtonType::TYPE_MARKER) {
type = CaptureButton::ButtonType::TYPE_MARKER;
}
CaptureModification tempMod(type, m_mousePos,
m_colorPicker->drawColor(),
m_thickness);
tempMod.addPoint(m_mousePos);
painter.drawPixmap(0, 0, m_screenshot->paintTemporalModification(
&tempMod));
} else {
painter.drawPixmap(0, 0, m_screenshot->screenshot());
}
QColor overlayColor(0, 0, 0, m_opacity);
painter.setBrush(overlayColor);
QRect r = m_selection.normalized().adjusted(0, 0, -1, -1);
QRegion grey(rect());
grey = grey.subtracted(r);
painter.setClipRegion(grey);
painter.drawRect(-1, -1, rect().width() + 1, rect().height() + 1);
painter.setClipRect(rect());
if (m_showInitialMsg) {
QRect helpRect = QGuiApplication::primaryScreen()->geometry();
QString helpTxt = tr("Select an area with the mouse, or press Esc to exit."
"\nPress Enter to capture the screen."
"\nPress Right Click to show the color picker."
"\nUse the Mouse Wheel to change the thickness of your tool.");
// We draw the white contrasting background for the text, using the
//same text and options to get the boundingRect that the text will have.
QRectF bRect = painter.boundingRect(helpRect, Qt::AlignCenter, helpTxt);
// These four calls provide padding for the rect
const int margin = QApplication::fontMetrics().height() / 2;
bRect.setWidth(bRect.width() + margin);
bRect.setHeight(bRect.height() + margin);
bRect.setX(bRect.x() - margin);
bRect.setY(bRect.y() - margin);
QColor rectColor(m_uiColor);
rectColor.setAlpha(180);
QColor textColor((CaptureButton::iconIsWhiteByColor(rectColor) ?
Qt::white : Qt::black));
painter.setBrush(QBrush(rectColor, Qt::SolidPattern));
painter.setPen(QPen(textColor));
painter.drawRect(bRect);
painter.drawText(helpRect, Qt::AlignCenter, helpTxt);
}
if (!m_selection.isNull()) {
// paint selection rect
painter.setPen(m_uiColor);
painter.setBrush(Qt::NoBrush);
painter.drawRect(r);
// paint handlers
painter.setRenderHint(QPainter::Antialiasing);
painter.setBrush(m_uiColor);
for(auto r: m_handles) {
painter.drawRoundRect(*r, 100, 100);
}
}
}
void CaptureWidget::mousePressEvent(QMouseEvent *e) {
if (e->button() == Qt::RightButton) {
m_rightClick = true;
m_colorPicker->move(e->pos().x()-m_colorPicker->width()/2,
e->pos().y()-m_colorPicker->height()/2);
m_colorPicker->show();
} else if (e->button() == Qt::LeftButton) {
m_showInitialMsg = false;
m_mouseIsClicked = true;
if (m_state != CaptureButton::TYPE_MOVESELECTION) {
auto mod = new CaptureModification(m_state, e->pos(),
m_colorPicker->drawColor(),
m_thickness,
this);
m_modifications.append(mod);
return;
}
m_dragStartPoint = e->pos();
m_selectionBeforeDrag = m_selection;
if (!m_selection.contains(e->pos()) && !m_mouseOverHandle) {
m_newSelection = true;
m_selection = QRect();
m_buttonHandler->hide();
update();
} else {
m_grabbing = true;
}
}
updateCursor();
}
void CaptureWidget::mouseMoveEvent(QMouseEvent *e) {
m_mousePos = e->pos();
if (m_mouseIsClicked && m_state == CaptureButton::TYPE_MOVESELECTION) {
if (m_buttonHandler->isVisible()) {
m_buttonHandler->hide();
}
if (m_newSelection) {
m_selection = QRect(m_dragStartPoint, m_mousePos).normalized();
updateHandles();
update();
} else if (!m_mouseOverHandle) {
// Moving the whole selection
QRect r = rect().normalized();
QRect initialRect = m_selection.normalized();
// new top left
QPoint p = initialRect.topLeft() + (e->pos() - m_dragStartPoint);
m_dragStartPoint += e->pos() - m_dragStartPoint;
m_selection.moveTo(p);
if (!r.contains(QPoint(r.center().x(), m_selection.top()))) {
m_selection.setTop(r.top());
} if (!r.contains(QPoint(m_selection.left(), r.center().y()))) {
m_selection.setLeft(r.left());
}
if (!r.contains(QPoint(m_selection.right(), r.center().y()))) {
m_selection.setRight(r.right());
} if (!r.contains(QPoint(r.center().x(), m_selection.bottom()))) {
m_selection.setBottom(r.bottom());
}
updateHandles();
update();
} else {
// Dragging a handle
QRect r = m_selectionBeforeDrag;
QPoint offset = e->pos() - m_dragStartPoint;
bool symmetryMod = qApp->keyboardModifiers() & Qt::ShiftModifier;
if (m_mouseOverHandle == &m_TLHandle || m_mouseOverHandle == &m_TSide
|| m_mouseOverHandle == &m_TRHandle)
{ // dragging one of the top handles
r.setTop(r.top() + offset.y());
if (symmetryMod) {
r.setBottom(r.bottom() - offset.y());
}
}
if (m_mouseOverHandle == &m_TLHandle || m_mouseOverHandle == &m_LSide
|| m_mouseOverHandle == &m_BLHandle)
{ // dragging one of the left handles
r.setLeft(r.left() + offset.x());
if (symmetryMod) {
r.setRight(r.right() - offset.x());
}
}
if (m_mouseOverHandle == &m_BLHandle || m_mouseOverHandle == &m_BSide
|| m_mouseOverHandle == &m_BRHandle)
{ // dragging one of the bottom handles
r.setBottom(r.bottom() + offset.y());
if (symmetryMod) {
r.setTop(r.top() - offset.y());
}
}
if (m_mouseOverHandle == &m_TRHandle || m_mouseOverHandle == &m_RSide
|| m_mouseOverHandle == &m_BRHandle)
{ // dragging one of the right handles
r.setRight(r.right() + offset.x());
if (symmetryMod) {
r.setLeft(r.left() - offset.x());
}
}
m_selection = r.normalized();
updateHandles();
update();
}
} else if (m_mouseIsClicked && m_state != CaptureButton::TYPE_MOVESELECTION) {
// drawing with a tool
m_modifications.last()->addPoint(e->pos());
update();
// Hides the buttons under the mouse. If the mouse leaves, it shows them.
if (m_buttonHandler->buttonsAreInside()) {
const bool containsMouse = m_buttonHandler->contains(m_mousePos);
if (containsMouse) {
m_buttonHandler->hide();
} else {
m_buttonHandler->show();
}
}
} else if (m_toolIsForDrawing) {
update();
} else {
if (m_selection.isNull()) {
return;
}
bool found = false;
for (QRect *const r: m_sides) {
if (r->contains(e->pos())) {
m_mouseOverHandle = r;
found = true;
break;
}
}
if (!found) {
m_mouseOverHandle = nullptr;
}
updateCursor();
}
}
void CaptureWidget::mouseReleaseEvent(QMouseEvent *e) {
if (e->button() == Qt::RightButton) {
m_colorPicker->hide();
m_rightClick = false;
// when we end the drawing of a modification in the capture we have to
// register the last point and add the whole modification to the screenshot
} else if (m_mouseIsClicked && m_state != CaptureButton::TYPE_MOVESELECTION) {
m_screenshot->paintModification(m_modifications.last());
update();
}
if (!m_buttonHandler->isVisible() && !m_selection.isNull()) {
updateSizeIndicator();
m_buttonHandler->updatePosition(m_selection);
m_buttonHandler->show();
}
m_mouseIsClicked = false;
m_newSelection = false;
m_grabbing = false;
updateCursor();
}
void CaptureWidget::keyPressEvent(QKeyEvent *e) {
if (m_selection.isNull()) {
return;
} else if (e->key() == Qt::Key_Up
&& m_selection.top() > rect().top()) {
m_selection.moveTop(m_selection.top()-1);
m_buttonHandler->updatePosition(m_selection);
updateHandles();
update();
} else if (e->key() == Qt::Key_Down
&& m_selection.bottom() < rect().bottom()) {
m_selection.moveBottom(m_selection.bottom()+1);
m_buttonHandler->updatePosition(m_selection);
updateHandles();
update();
} else if (e->key() == Qt::Key_Left
&& m_selection.left() > rect().left()) {
m_selection.moveLeft(m_selection.left()-1);
m_buttonHandler->updatePosition(m_selection);
updateHandles();
update();
} else if (e->key() == Qt::Key_Right
&& m_selection.right() < rect().right()) {
m_selection.moveRight(m_selection.right()+1);
m_buttonHandler->updatePosition(m_selection);
updateHandles();
update();
}
}
void CaptureWidget::wheelEvent(QWheelEvent *e) {
m_thickness += e->delta() / 120;
m_thickness = qBound(0, m_thickness, 100);
m_notifierBox->showMessage(QString::number(m_thickness));
if (m_toolIsForDrawing) {
update();
}
}
bool CaptureWidget::undo() {
bool itemRemoved = false;
if (!m_modifications.isEmpty()) {
m_modifications.last()->deleteLater();
m_modifications.pop_back();
m_screenshot->overrideModifications(m_modifications);
update();
itemRemoved = true;
}
return itemRemoved;
}
void CaptureWidget::setState(CaptureButton *b) {
CaptureButton::ButtonType t = b->buttonType();
if (b->tool()->isSelectable()) {
if (t != m_state) {
m_state = t;
m_toolIsForDrawing =
(b->tool()->toolType() !=
CaptureTool::ToolWorkType::TYPE_WORKER) &&
b->buttonType() != CaptureButton::TYPE_BLUR;
if (m_lastPressedButton) {
m_lastPressedButton->setColor(m_uiColor);
}
m_lastPressedButton = b;
m_lastPressedButton->setColor(m_contrastUiColor);
} else {
handleButtonSignal(CaptureTool::REQ_MOVE_MODE);
}
update(); // clear mouse preview
}
}
void CaptureWidget::handleButtonSignal(CaptureTool::Request r) {
switch (r) {
case CaptureTool::REQ_CLEAR_MODIFICATIONS:
while(undo());
break;
case CaptureTool::REQ_CLOSE_GUI:
close();
break;
case CaptureTool::REQ_HIDE_GUI:
hide();
break;
case CaptureTool::REQ_HIDE_SELECTION:
m_newSelection = true;
m_selection = QRect();
updateCursor();
break;
case CaptureTool::REQ_SAVE_SCREENSHOT:
saveScreenshot();
break;
case CaptureTool::REQ_SELECT_ALL:
m_selection = rect();
break;
case CaptureTool::REQ_TO_CLIPBOARD:
copyScreenshot();
break;
case CaptureTool::REQ_UNDO_MODIFICATION:
undo();
break;
case CaptureTool::REQ_UPLOAD_TO_IMGUR:
uploadToImgur();
break;
case CaptureTool::REQ_OPEN_APP:
openWithProgram();
break;
case CaptureTool::REQ_MOVE_MODE:
m_state = CaptureButton::TYPE_MOVESELECTION;
m_toolIsForDrawing = false;
if (m_lastPressedButton) {
m_lastPressedButton->setColor(m_uiColor);
m_lastPressedButton = nullptr;
}
break;
default:
break;
}
}
void CaptureWidget::leftResize() {
if (!m_selection.isNull() && m_selection.right() > m_selection.left()) {
m_selection.setRight(m_selection.right()-1);
m_buttonHandler->updatePosition(m_selection);
updateSizeIndicator();
updateHandles();
update();
}
}
void CaptureWidget::rightResize() {
if (!m_selection.isNull() && m_selection.right() < rect().right()) {
m_selection.setRight(m_selection.right()+1);
m_buttonHandler->updatePosition(m_selection);
updateSizeIndicator();
updateHandles();
update();
}
}
void CaptureWidget::upResize() {
if (!m_selection.isNull() && m_selection.bottom() > m_selection.top()) {
m_selection.setBottom(m_selection.bottom()-1);
m_buttonHandler->updatePosition(m_selection);
updateSizeIndicator();
updateHandles();
update();
}
}
void CaptureWidget::downResize() {
if (!m_selection.isNull() && m_selection.bottom() < rect().bottom()) {
m_selection.setBottom(m_selection.bottom()+1);
m_buttonHandler->updatePosition(m_selection);
updateSizeIndicator();
updateHandles();
update();
}
}
void CaptureWidget::initShortcuts() {
new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q), this, SLOT(close()));
new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_S), this, SLOT(saveScreenshot()));
new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_C), this, SLOT(copyScreenshot()));
new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Z), this, SLOT(undo()));
new QShortcut(QKeySequence(Qt::SHIFT + Qt::Key_Right), this, SLOT(rightResize()));
new QShortcut(QKeySequence(Qt::SHIFT + Qt::Key_Left), this, SLOT(leftResize()));
new QShortcut(QKeySequence(Qt::SHIFT + Qt::Key_Up), this, SLOT(upResize()));
new QShortcut(QKeySequence(Qt::SHIFT + Qt::Key_Down), this, SLOT(downResize()));
new QShortcut(Qt::Key_Escape, this, SLOT(close()));
new QShortcut(Qt::Key_Return, this, SLOT(copyScreenshot()));
}
void CaptureWidget::updateHandles() {
QRect r = m_selection.normalized().adjusted(0, 0, -1, -1);
int s2 = handleSize() / 2;
m_TLHandle.moveTopLeft(QPoint(r.x() - s2, r.y() - s2));
m_TRHandle.moveTopRight(QPoint(r.right() + s2, r.y() - s2));
m_BRHandle.moveBottomRight(QPoint(r.x() + r.width() + s2, r.bottom() + s2));
m_BLHandle.moveBottomLeft(QPoint(QPoint(r.x() - s2, r.bottom() + s2)));
m_LHandle.moveTopLeft(QPoint(r.x() - s2, r.y() + r.height() / 2 - s2));
m_THandle.moveTopLeft(QPoint(r.x() + r.width() / 2 - s2, r.y() - s2));
m_RHandle.moveTopRight(QPoint(r.right() + s2, r.y() + r.height() / 2 - s2));
m_BHandle.moveBottomLeft(QPoint(r.x() + r.width() / 2 - s2, r.bottom() + s2));
m_LSide = QRect(m_TLHandle.bottomLeft(), m_BLHandle.topRight());
m_RSide = QRect(m_TRHandle.bottomLeft(), m_BRHandle.topRight());
m_BSide = QRect(m_BLHandle.topRight(), m_BRHandle.bottomLeft());
m_TSide = QRect(m_TLHandle.topRight(), m_TRHandle.bottomLeft());
}
void CaptureWidget::updateSizeIndicator() {
if (m_sizeIndButton){
const QRect &selection = extendedSelection();
m_sizeIndButton->setText(QStringLiteral("%1\n%2")
.arg(selection.width())
.arg(selection.height()));
}
}
void CaptureWidget::updateCursor() {
if (m_rightClick) {
setCursor(Qt::ArrowCursor);
} else if (m_grabbing) {
setCursor(Qt::ClosedHandCursor);
} else if (m_state == CaptureButton::TYPE_MOVESELECTION) {
if (m_mouseOverHandle){
// cursor on the handlers
if (m_mouseOverHandle == &m_TLHandle || m_mouseOverHandle == &m_BRHandle) {
setCursor(Qt::SizeFDiagCursor);
} else if (m_mouseOverHandle == &m_TRHandle || m_mouseOverHandle == &m_BLHandle) {
setCursor(Qt::SizeBDiagCursor);
} else if (m_mouseOverHandle == &m_LSide || m_mouseOverHandle == &m_RSide) {
setCursor(Qt::SizeHorCursor);
} else if (m_mouseOverHandle == &m_TSide || m_mouseOverHandle == &m_BSide) {
setCursor(Qt::SizeVerCursor);
}
} else if (m_selection.contains(m_mousePos)) {
setCursor(Qt::OpenHandCursor);
} else {
setCursor(Qt::CrossCursor);
}
} else {
setCursor(Qt::CrossCursor);
}
}
int CaptureWidget::handleSize() {
return (QApplication::fontMetrics().height() * 0.7);
}
void CaptureWidget::copyScreenshot() {
m_captureDone = true;
hide();
ResourceExporter().captureToClipboard(pixmap());
close();
}
void CaptureWidget::saveScreenshot() {
m_captureDone = true;
hide();
if (m_forcedSavePath.isEmpty()) {
ResourceExporter().captureToFileUi(pixmap());
} else {
ResourceExporter().captureToFile(pixmap(), m_forcedSavePath);
}
close();
}
void CaptureWidget::uploadToImgur() {
m_captureDone = true;
hide();
ResourceExporter().captureToImgur(pixmap());
close();
}
void CaptureWidget::openWithProgram() {
m_captureDone = true;
hide();
ResourceExporter().captureToProgram(pixmap());
close();
}
QRect CaptureWidget::extendedSelection() const {
if (m_selection.isNull())
return QRect();
auto devicePixelRatio = m_screenshot->screenshot().devicePixelRatio();
return QRect(m_selection.left() * devicePixelRatio,
m_selection.top() * devicePixelRatio,
m_selection.width() * devicePixelRatio,
m_selection.height() * devicePixelRatio);
}

142
src/capture/widget/capturewidget.h
View File

@@ -1,142 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
// Based on Lightscreen areadialog.h, Copyright 2017 Christian Kaiser <info@ckaiser.com.ar>
// released under the GNU GPL2 <https://www.gnu.org/licenses/gpl-2.0.txt>
// Based on KDE's KSnapshot regiongrabber.cpp, revision 796531, Copyright 2007 Luca Gugelmann <lucag@student.ethz.ch>
// released under the GNU LGPL <http://www.gnu.org/licenses/old-licenses/library.txt>
#pragma once
#include "capturebutton.h"
#include "src/capture/tools/capturetool.h"
#include "src/utils/confighandler.h"
#include "buttonhandler.h"
#include <QWidget>
#include <QPointer>
class QPaintEvent;
class QResizeEvent;
class QMouseEvent;
class CaptureModification;
class QNetworkAccessManager;
class QNetworkReply;
class ColorPicker;
class Screenshot;
class NotifierBox;
class CaptureWidget : public QWidget {
Q_OBJECT
public:
explicit CaptureWidget(const uint id = 0,
const QString &forcedSavePath = QString(),
QWidget *parent = nullptr);
~CaptureWidget();
void updateButtons();
QPixmap pixmap();
signals:
void captureTaken(uint id, QByteArray p);
void captureFailed(uint id);
private slots:
void copyScreenshot();
void saveScreenshot();
void uploadToImgur();
void openWithProgram();
bool undo();
void leftResize();
void rightResize();
void upResize();
void downResize();
void setState(CaptureButton *);
void handleButtonSignal(CaptureTool::Request r);
protected:
void paintEvent(QPaintEvent *);
void mousePressEvent(QMouseEvent *);
void mouseMoveEvent(QMouseEvent *);
void mouseReleaseEvent(QMouseEvent *);
void keyPressEvent(QKeyEvent *);
void wheelEvent(QWheelEvent *);
// pixel map of the screen
Screenshot* m_screenshot;
QPoint m_dragStartPoint;
QPoint m_mousePos;
// pointer to the handlers under the mouse
QRect *m_mouseOverHandle;
QRect m_selection;
QRect m_selectionBeforeDrag;
// utility flags
bool m_mouseIsClicked;
bool m_rightClick;
bool m_newSelection;
bool m_grabbing;
bool m_showInitialMsg;
bool m_captureDone;
bool m_toolIsForDrawing;
const QString m_forcedSavePath;
int m_thickness;
int m_opacity;
uint m_id;
NotifierBox *m_notifierBox;
// naming convention for handles
// T top, B bottom, R Right, L left
// 2 letters: a corner
// 1 letter: the handle on the middle of the corresponding side
QRect m_TLHandle, m_TRHandle, m_BLHandle, m_BRHandle;
QRect m_LHandle, m_THandle, m_RHandle, m_BHandle;
// Side Rects
QRect m_LSide, m_TSide, m_RSide, m_BSide;
// list containing the active habdlers
QVector<QRect*> m_handles;
QVector<QRect*> m_sides;
private:
void initShortcuts();
void updateHandles();
void updateSizeIndicator();
void updateCursor();
// size of the handlers at the corners of the selection
int handleSize();
QRect extendedSelection() const;
QVector<CaptureModification*> m_modifications;
QPointer<CaptureButton> m_sizeIndButton;
QPointer<CaptureButton> m_lastPressedButton;
CaptureButton::ButtonType m_state;
ButtonHandler *m_buttonHandler;
QColor m_uiColor;
QColor m_contrastUiColor;
ColorPicker *m_colorPicker;
ConfigHandler m_config;
};

113
src/capture/widget/colorpicker.cpp
View File

@@ -1,113 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "colorpicker.h"
#include "src/utils/confighandler.h"
#include "src/capture/widget/capturebutton.h"
#include <QPainter>
#include <QMouseEvent>
ColorPicker::ColorPicker(QWidget *parent) : QWidget(parent) {
ConfigHandler config;
m_colorList = config.getUserColors();
m_colorAreaSize = CaptureButton::buttonBaseSize() * 0.6;
setMouseTracking(true);
// save the color values in member variables for faster access
m_uiColor = config.uiMainColorValue();
m_drawColor = config.drawColorValue();
// extraSize represents the extra space needed for the highlight of the
// selected color.
const int extraSize = 6;
double radius = (m_colorList.size()*m_colorAreaSize/1.3)/(3.141592);
resize(radius*2 + m_colorAreaSize + extraSize,
radius*2 + m_colorAreaSize+ extraSize);
double degree = 360 / (m_colorList.size());
double degreeAcum = degree;
// this line is the radius of the circle which will be rotated to add
// the color components.
QLineF baseLine = QLineF(QPoint(radius+extraSize/2, radius+extraSize/2),
QPoint(radius*2, radius));
for (int i = 0; i<m_colorList.size(); ++i) {
m_colorAreaList.append(QRect(baseLine.x2(), baseLine.y2(),
m_colorAreaSize, m_colorAreaSize));
baseLine.setAngle(degreeAcum);
degreeAcum += degree;
}
}
ColorPicker::~ColorPicker() {
ConfigHandler().setDrawColor(m_drawColor);
}
QColor ColorPicker::drawColor() {
return m_drawColor;
}
void ColorPicker::show() {
grabMouse();
QWidget::show();
}
void ColorPicker::hide() {
releaseMouse();
QWidget::hide();
}
void ColorPicker::paintEvent(QPaintEvent *) {
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
QVector<QRect> rects = handleMask();
painter.setPen(QColor(Qt::black));
for (int i = 0; i < rects.size(); ++i) {
// draw the highlight when we have to draw the selected color
if (m_drawColor == QColor(m_colorList.at(i))) {
QColor c = QColor(m_uiColor);
c.setAlpha(155);
painter.setBrush(c);
c.setAlpha(100);
painter.setPen(c);
QRect highlight = rects.at(i);
highlight.moveTo(highlight.x() - 3, highlight.y() - 3);
highlight.setHeight(highlight.height() + 6);
highlight.setWidth(highlight.width() + 6);
painter.drawRoundRect(highlight, 100, 100);
painter.setPen(QColor(Qt::black));
}
painter.setBrush(QColor(m_colorList.at(i)));
painter.drawRoundRect(rects.at(i), 100, 100);
}
}
void ColorPicker::mouseMoveEvent(QMouseEvent *e) {
for (int i = 0; i < m_colorList.size(); ++i) {
if (m_colorAreaList.at(i).contains(e->pos())) {
m_drawColor = m_colorList.at(i);
update();
break;
}
}
}
QVector<QRect> ColorPicker::handleMask() const {
QVector<QRect> areas;
for (const QRect &rect: m_colorAreaList) {
areas.append(rect);
}
return areas;
}

47
src/capture/widget/colorpicker.h
View File

@@ -1,47 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <QWidget>
class ColorPicker : public QWidget
{
Q_OBJECT
public:
explicit ColorPicker(QWidget *parent = nullptr);
~ColorPicker();
QColor drawColor();
void show();
void hide();
protected:
void paintEvent(QPaintEvent *);
void mouseMoveEvent(QMouseEvent *);
QVector<QRect> handleMask() const;
private:
int m_colorAreaSize;
QVector<QRect> m_colorAreaList;
QVector<QColor> m_colorList;
QColor m_uiColor, m_drawColor;
};

61
src/capture/widget/notifierbox.cpp
View File

@@ -1,61 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "notifierbox.h"
#include "src/utils/confighandler.h"
#include "src/capture/widget/capturebutton.h"
#include <QTimer>
#include <QPainter>
#include <QApplication>
NotifierBox::NotifierBox(QWidget *parent) : QWidget(parent) {
m_timer = new QTimer(this);
m_timer->setSingleShot(true);
m_timer->setInterval(1200);
connect(m_timer, &QTimer::timeout, this, &NotifierBox::hide);
m_bgColor = ConfigHandler().uiMainColorValue();
m_foregroundColor = (CaptureButton::iconIsWhiteByColor(m_bgColor) ?
Qt::white : Qt::black);
m_bgColor.setAlpha(180);
const int size = (CaptureButton::buttonBaseSize() +
CaptureButton::buttonBaseSize()/2) *
qApp->devicePixelRatio();
setFixedSize(QSize(size, size));
}
void NotifierBox::enterEvent(QEvent *) {
hide();
}
void NotifierBox::paintEvent(QPaintEvent *) {
QPainter painter(this);
// draw Elipse
painter.setRenderHint(QPainter::Antialiasing);
painter.setBrush(QBrush(m_bgColor, Qt::SolidPattern));
painter.setPen(QPen(Qt::transparent));
painter.drawEllipse(rect());
// Draw the text:
painter.setPen(QPen(m_foregroundColor));
painter.drawText(rect(), Qt::AlignCenter, m_message);
}
void NotifierBox::showMessage(const QString &msg) {
m_message = msg;
update();
show();
m_timer->start();
}

42
src/capture/widget/notifierbox.h
View File

@@ -1,42 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <QWidget>
class QTimer;
class NotifierBox : public QWidget
{
Q_OBJECT
public:
explicit NotifierBox(QWidget *parent = nullptr);
protected:
virtual void enterEvent(QEvent *);
virtual void paintEvent(QPaintEvent *);
public slots:
void showMessage(const QString &msg);
private:
QTimer *m_timer;
QString m_message;
QColor m_bgColor;
QColor m_foregroundColor;
};

87
src/capture/workers/imgur/imagelabel.cpp
View File

@@ -1,87 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
// This code is a modified version of the KDE software Spectacle
// /src/Gui/KSImageWidget.cpp commit cbbd6d45f6426ccbf1a82b15fdf98613ccccbbe9
#include "imagelabel.h"
ImageLabel::ImageLabel(QWidget *parent):
QLabel(parent), m_pixmap(QPixmap())
{
m_DSEffect = new QGraphicsDropShadowEffect(this);
m_DSEffect->setBlurRadius(5);
m_DSEffect->setOffset(0);
m_DSEffect->setColor(QColor(Qt::black));
setGraphicsEffect(m_DSEffect);
setCursor(Qt::OpenHandCursor);
setAlignment(Qt::AlignCenter);
setMinimumSize(size());
}
void ImageLabel::setScreenshot(const QPixmap &pixmap) {
m_pixmap = pixmap;
const QString tooltip = QStringLiteral("%1x%2 px").arg(m_pixmap.width())
.arg(m_pixmap.height());
setToolTip(tooltip);
setScaledPixmap();
}
void ImageLabel::setScaledPixmap() {
const qreal scale = qApp->devicePixelRatio();
QPixmap scaledPixmap = m_pixmap.scaled(size() * scale, Qt::KeepAspectRatio,
Qt::SmoothTransformation);
scaledPixmap.setDevicePixelRatio(scale);
setPixmap(scaledPixmap);
}
// drag handlers
void ImageLabel::mousePressEvent(QMouseEvent *event) {
if (event->button() == Qt::LeftButton) {
m_dragStartPosition = event->pos();
setCursor(Qt::ClosedHandCursor);
}
}
void ImageLabel::mouseReleaseEvent(QMouseEvent *event) {
if (event->button() == Qt::LeftButton) {
setCursor(Qt::OpenHandCursor);
}
}
void ImageLabel::mouseMoveEvent(QMouseEvent *event)
{
if (!(event->buttons() & Qt::LeftButton)) {
return;
}
if ((event->pos() - m_dragStartPosition).manhattanLength() <
QGuiApplication::styleHints()->startDragDistance())
{
return;
}
setCursor(Qt::OpenHandCursor);
emit dragInitiated();
}
// resize handler
void ImageLabel::resizeEvent(QResizeEvent *event) {
Q_UNUSED(event);
setScaledPixmap();
}

56
src/capture/workers/imgur/imagelabel.h
View File

@@ -1,56 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
// This code is a modified version of the KDE software Spectacle
// /src/Gui/KSImageWidget.h commit cbbd6d45f6426ccbf1a82b15fdf98613ccccbbe9
#pragma once
#include <QGuiApplication>
#include <QStyleHints>
#include <QLabel>
#include <QColor>
#include <QMouseEvent>
#include <QPoint>
#include <QPixmap>
#include <QGraphicsDropShadowEffect>
class ImageLabel : public QLabel
{
Q_OBJECT
public:
explicit ImageLabel(QWidget *parent = 0);
void setScreenshot(const QPixmap &pixmap);
signals:
void dragInitiated();
protected:
void mousePressEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
void mouseReleaseEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
void mouseMoveEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
void resizeEvent(QResizeEvent *event) Q_DECL_OVERRIDE;
private:
void setScaledPixmap();
QGraphicsDropShadowEffect *m_DSEffect;
QPixmap m_pixmap;
QPoint m_dragStartPosition;
};

6
src/capture/workers/imgur/imguruploader.cpp
View File

@@ -18,9 +18,9 @@
#include "imguruploader.h"
#include "src/utils/filenamehandler.h"
#include "src/utils/systemnotification.h"
#include "src/capture/workers/imgur/loadspinner.h"
#include "src/capture/workers/imgur/imagelabel.h"
#include "src/capture/workers/imgur/notificationwidget.h"
#include "src/widgets/loadspinner.h"
#include "src/widgets/imagelabel.h"
#include "src/widgets/notificationwidget.h"
#include "src/utils/confighandler.h"
#include <QApplication>
#include <QClipboard>

96
src/capture/workers/imgur/loadspinner.cpp
View File

@@ -1,96 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "loadspinner.h"
#include <QPaintEvent>
#include <QPainter>
#include <QTimer>
#include <QApplication>
#define OFFSET 5
LoadSpinner::LoadSpinner(QWidget *parent) :
QWidget(parent), m_startAngle(0), m_span(0), m_growing(true)
{
setAttribute(Qt::WA_TranslucentBackground);
const int size = QApplication::fontMetrics().height() * 8;
setFixedSize(size, size);
updateFrame();
// init timer
m_timer = new QTimer(this);
connect(m_timer, SIGNAL(timeout()), this, SLOT(rotate()));
m_timer->setInterval(30);
}
void LoadSpinner::setColor(const QColor &c) {
m_color = c;
}
void LoadSpinner::setWidth(int w) {
setFixedSize(w, w);
updateFrame();
}
void LoadSpinner::setHeight(int h) {
setFixedSize(h, h);
updateFrame();
}
void LoadSpinner::start() {
m_timer->start();
}
void LoadSpinner::stop() {
m_timer->stop();
}
void LoadSpinner::paintEvent(QPaintEvent *) {
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
auto pen = QPen(m_color);
pen.setWidth(height()/10);
painter.setPen(pen);
painter.setOpacity(0.2);
painter.drawArc(m_frame, 0, 5760);
painter.setOpacity(1.0);
painter.drawArc(m_frame, (m_startAngle * 16), (m_span * 16));
}
void LoadSpinner::rotate() {
const int advance = 3;
const int grow = 8;
if (m_growing) {
m_startAngle = (m_startAngle + advance) % 360;
m_span += grow;
if(m_span > 260) {
m_growing = false;
}
} else {
m_startAngle = (m_startAngle + grow) % 360;
m_span = m_span + advance - grow;
if(m_span < 10) {
m_growing = true;
}
}
update();
}
void LoadSpinner::updateFrame() {
m_frame = QRect(OFFSET, OFFSET, width() - OFFSET*2, height() - OFFSET*2);
}

50
src/capture/workers/imgur/loadspinner.h
View File

@@ -1,50 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <QWidget>
class LoadSpinner : public QWidget
{
Q_OBJECT
public:
explicit LoadSpinner(QWidget *parent = nullptr);
void setColor(const QColor &c);
void setWidth(int w);
void setHeight(int h);
void start();
void stop();
protected:
void paintEvent(QPaintEvent *);
private slots:
void rotate();
private:
QColor m_color;
QTimer *m_timer;
int m_startAngle = 0;
int m_span =180;
bool m_growing;
QRect m_frame;
void updateFrame();
};

73
src/capture/workers/imgur/notificationwidget.cpp
View File

@@ -1,73 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "notificationwidget.h"
#include <QLabel>
#include <QTimer>
#include <QLabel>
#include <QPropertyAnimation>
#include <QVBoxLayout>
#include <QFrame>
#include <QIcon>
NotificationWidget::NotificationWidget(QWidget *parent) : QWidget(parent)
{
m_timer = new QTimer(this);
m_timer->setSingleShot(true);
m_timer->setInterval(7000);
connect(m_timer, &QTimer::timeout, this, &NotificationWidget::animatedHide);
m_content = new QFrame();
m_layout = new QVBoxLayout();
m_label = new QLabel(m_content);
m_label->hide();
m_showAnimation = new QPropertyAnimation(m_content, "geometry", this);
m_showAnimation->setDuration(300);
m_hideAnimation = new QPropertyAnimation(m_content, "geometry", this);
m_hideAnimation->setDuration(300);
connect(m_hideAnimation, &QPropertyAnimation::finished, m_label, &QLabel::hide);
auto mainLayout = new QVBoxLayout();
setLayout(mainLayout);
mainLayout->addWidget(m_content);
m_layout->addWidget(m_label, 0, Qt::AlignHCenter);
m_content->setLayout(m_layout);
setFixedHeight(40);
}
void NotificationWidget::showMessage(const QString &msg) {
m_label->setText(msg);
m_label->show();
animatedShow();
}
void NotificationWidget::animatedShow() {
m_showAnimation->setStartValue(QRect(0, 0, width(), 0));
m_showAnimation->setEndValue(QRect(0, 0, width(), height()));
m_showAnimation->start();
m_timer->start();
}
void NotificationWidget::animatedHide() {
m_hideAnimation->setStartValue(QRect(0, 0, width(), height()));
m_hideAnimation->setEndValue(QRect(0, 0, width(), 0));
m_hideAnimation->start();
}

47
src/capture/workers/imgur/notificationwidget.h
View File

@@ -1,47 +0,0 @@
// Copyright(c) 2017-2018 Alejandro Sirgo Rica & Contributors
//
// This file is part of Flameshot.
//
// Flameshot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Flameshot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <QWidget>
class QLabel;
class QTimer;
class QPropertyAnimation;
class QVBoxLayout;
class QFrame;
class NotificationWidget : public QWidget
{
Q_OBJECT
public:
explicit NotificationWidget(QWidget *parent = nullptr);
void showMessage(const QString &msg);
private:
QLabel *m_label;
QPropertyAnimation *m_showAnimation;
QPropertyAnimation *m_hideAnimation;
QVBoxLayout *m_layout;
QFrame *m_content;
QTimer *m_timer;
void animatedShow();
void animatedHide();
};

2
src/capture/workers/launcher/applauncherwidget.cpp
View File

@@ -18,7 +18,7 @@
#include "applauncherwidget.h"
#include "src/utils/filenamehandler.h"
#include "src/capture/workers/launcher/launcheritemdelegate.h"
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include "src/utils/confighandler.h"
#include "terminallauncher.h"
#include <QDir>

2
src/capture/workers/launcher/launcheritemdelegate.cpp
View File

@@ -16,7 +16,7 @@
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "launcheritemdelegate.h"
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include <QPainter>
LauncherItemDelegate::LauncherItemDelegate(QObject *parent) :

2
src/config/buttonlistview.h
View File

@@ -17,7 +17,7 @@
#pragma once
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include <QListWidget>
class ButtonListView : public QListWidget {

2
src/config/configwindow.cpp
View File

@@ -16,7 +16,7 @@
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "configwindow.h"
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include "src/config/geneneralconf.h"
#include "src/config/filenameeditor.h"
#include "src/config/strftimechooserwidget.h"

2
src/config/uicoloreditor.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "color_wheel.hpp"
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include <QGroupBox>
class QVBoxLayout;

4
src/core/controller.cpp
View File

@@ -16,11 +16,11 @@
// along with Flameshot. If not, see <http://www.gnu.org/licenses/>.
#include "controller.h"
#include "src/capture/widget/capturewidget.h"
#include "src/capture/widgets/capturewidget.h"
#include "src/utils/confighandler.h"
#include "src/infowindow.h"
#include "src/config/configwindow.h"
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include <QFile>
#include <QApplication>
#include <QSystemTrayIcon>

2
src/utils/confighandler.h
View File

@@ -17,7 +17,7 @@
#pragma once
#include "src/capture/widget/capturebutton.h"
#include "src/capture/widgets/capturebutton.h"
#include <QVector>
#include <QSettings>