PaintingArea.cpp

Go to the documentation of this file.

// ---------- PaintingArea.cpp ----------
#include "string.h"
 
#include <vector>
 
#include <QtWidgets>
#include <QPoint>
#include <QRect>
 
#include "PaintingArea.h"
#include "Image/IntelliRasterImage.h"
#include "Image/IntelliShapedImage.h"
#include "Tool/IntelliToolPen.h"
#include "Tool/IntelliToolPlain.h"
#include "Tool/IntelliToolLine.h"
#include "Tool/IntelliToolCircle.h"
#include "Tool/IntelliToolRectangle.h"
#include "Tool/IntelliToolFloodFill.h"
#include "Tool/IntelliToolPolygon.h"
#include "Tool/IntelliToolGradient.h"
#include "GUI/IntelliPhotoGui.h"
 
LayerObject::LayerObject(){
 
}
 
LayerObject::LayerObject(const LayerObject& layer){
        if(layer.image->getTypeOfImage()==ImageType::RASTERIMAGE) {
                this->image = new IntelliRasterImage(*dynamic_cast<IntelliRasterImage*>(layer.image));
        }else if(layer.image->getTypeOfImage()==ImageType::SHAPEDIMAGE) {
                this->image = new IntelliShapedImage(*dynamic_cast<IntelliShapedImage*>(layer.image));
        }
        this->width = layer.width;
        this->height = layer.height;
        this->widthOffset = layer.widthOffset;
        this->heightOffset = layer.heightOffset;
        this->alpha = layer.alpha;
}
 
PaintingArea::PaintingArea(int newMaxWidth, int newMaxHeight, QWidget*parent)
        : QLabel(parent){
        this->Tool = nullptr;
        this->setCanvasDimensions(newMaxWidth, newMaxHeight);
        activeLayer = -1;
}
 
PaintingArea::~PaintingArea(){
        delete Tool;
}
 
void PaintingArea::setRenderSettings(bool isFastRenderingOn){
        bool ToolIsActive;
 
        if(Tool!=nullptr) {
                ToolIsActive = Tool->getIsDrawing();
        }
        else{
                ToolIsActive = false;
        }
        if(isFastRenderingOn != renderSettings.isFastRenderering() && !ToolIsActive) {
                renderSettings.setFastRendering(isFastRenderingOn);
                for(auto& layer : layerBundle) {
                        layer.image->updateRendererSetting(isFastRenderingOn);
                }
        }
}
 
bool PaintingArea::getRenderSettings(){
        return this->renderSettings.isFastRenderering();
}
 
void PaintingArea::setCanvasDimensions(int newMaxWidth, int newMaxHeight){
        //set standart parameter
        this->maxWidth = newMaxWidth;
        this->maxHeight = newMaxHeight;
        Canvas = new QImage(maxWidth,maxHeight, QImage::Format_ARGB32);
 
        this->offsetXDimension = maxWidth / 2;
        this->offsetYDimension = maxHeight / 2;
 
        // Roots the widget to the top left even if resized
        setAttribute(Qt::WA_StaticContents);
 
}
 
void PaintingArea::drawPixelOntoActive(QColor color, QPoint point){
        layerBundle[static_cast<size_t>(activeLayer)].image->drawPixel(point, color);
}
 
void PaintingArea::setPolygonDataToActive(std::vector<QPoint> points){
        layerBundle[static_cast<size_t>(activeLayer)].image->setPolygon(points);
}
 
int PaintingArea::addLayer(int width, int height, int widthOffset, int heightOffset,int alpha, ImageType type){
        LayerObject newLayer;
        updateTools();
        newLayer.width = width;
        newLayer.height = height;
        newLayer.widthOffset = widthOffset;
        newLayer.heightOffset = heightOffset;
        newLayer.alpha = alpha;
        if(type==ImageType::RASTERIMAGE) {
                newLayer.image = new IntelliRasterImage(width,height,renderSettings.isFastRenderering());
        }else if(type==ImageType::SHAPEDIMAGE) {
                newLayer.image = new IntelliShapedImage(width, height, renderSettings.isFastRenderering());
        }
        this->layerBundle.push_back(newLayer);
        activeLayer = static_cast<int>(layerBundle.size()) - 1;
        return activeLayer;
}
 
 
void PaintingArea::deleteLayer(int idx, bool isTool){
        if(!isTool) {
                updateTools();
        }
        if(idx<static_cast<int>(layerBundle.size())&&idx>=0) {
                this->layerBundle.erase(layerBundle.begin() + idx);
                if(activeLayer>=idx) {
                        activeLayer--;
                }
                if(activeLayer < 0 && layerBundle.size()) {
                        activeLayer = 0;
                }
        }
}
 
void PaintingArea::slotDeleteActiveLayer(){
        if(activeLayer>=0 && activeLayer < static_cast<int>(layerBundle.size())) {
                this->layerBundle.erase(layerBundle.begin() + activeLayer);
                activeLayer--;
        }
        historyadd();
}
 
void PaintingArea::setLayerActive(int idx){
        updateTools();
        if(idx>=0&&idx<static_cast<int>(layerBundle.size())) {
                this->activeLayer = idx;
        }
}
 
void PaintingArea::setLayerAlpha(int idx, int alpha){
        if(idx>=0&&idx<static_cast<int>(layerBundle.size())) {
                if(alpha>=0 && alpha<=255) {
                        layerBundle[static_cast<size_t>(idx)].alpha = alpha;
                }
        }
}
void PaintingArea::setPolygon(int idx){
        if(idx>=0&&idx<static_cast<int>(layerBundle.size())) {
                if(layerBundle[static_cast<size_t>(idx)].image->getTypeOfImage()==ImageType::SHAPEDIMAGE) {
                        delete this->Tool;
                        this->Tool = new IntelliToolPolygon(this,&colorPicker,&Toolsettings, true);
                        isSettingPolygon = true;
                        this->guiReference->setToolWidth(5);
                }
        }
}
 
// Used to load the image and place it in the widget
bool PaintingArea::open(const QString &filePath){
        if(this->activeLayer==-1) {
                return false;
        }
        IntelliImage* active = layerBundle[static_cast<size_t>(activeLayer)].image;
        bool open = active->loadImage(filePath);
        active->calculateVisiblity();
        update();
        return open;
}
 
void PaintingArea::deleteAllLayers(){
        for(auto layer: layerBundle) {
                delete layer.image;
        }
        layerBundle.clear();
}
 
// Save the current image
bool PaintingArea::save(const QString &filePath, const char*fileFormat){
        if(layerBundle.size()==0) {
                return false;
        }
        this->drawLayers(true);
 
        if(!strcmp(fileFormat,"PNG")) {
                QImage visibleImage = Canvas->convertToFormat(QImage::Format_Indexed8);
                fileFormat = "png";
                if (visibleImage.save(filePath, fileFormat)) {
                        return true;
                } else {
                        return false;
                }
        }
 
        if (Canvas->save(filePath, fileFormat)) {
                return true;
        } else {
                return false;
        }
}
 
void PaintingArea::movePositionActive(int x, int y){
        updateTools();
        layerBundle[static_cast<size_t>(activeLayer)].widthOffset += x;
        layerBundle[static_cast<size_t>(activeLayer)].heightOffset += y;
        historyadd();
}
 
void PaintingArea::moveActiveLayer(int idx){
        updateTools();
        if(idx==1) {
                this->selectLayerUp();
        }else if(idx==-1) {
                this->selectLayerDown();
        }
        guiReference->UpdateGui();
        historyadd();
}
 
void PaintingArea::slotActivateLayer(int a){
        updateTools();
        if(a>=0 && a < static_cast<int>(layerBundle.size())) {
                this->setLayerActive(a);
        }
}
 
void PaintingArea::colorPickerSetFirstColor(){
        QColor clr = QColorDialog::getColor(colorPicker.getFirstColor(), nullptr, "Main Color", QColorDialog::DontUseNativeDialog);
        this->colorPicker.setFirstColor(clr);
}
 
void PaintingArea::colorPickerSetSecondColor(){
        QColor clr = QColorDialog::getColor(colorPicker.getSecondColor(), nullptr, "Secondary Color", QColorDialog::DontUseNativeDialog);
        this->colorPicker.setSecondColor(clr);
}
 
void PaintingArea::colorPickerSwapColors(){
        this->colorPicker.swapColors();
}
 
void PaintingArea::createPenTool(){
        delete this->Tool;
        Tool = new IntelliToolPen(this, &colorPicker, &Toolsettings);
}
 
void PaintingArea::createPlainTool(){
        delete this->Tool;
        Tool = new IntelliToolPlainTool(this, &colorPicker, &Toolsettings);
}
 
void PaintingArea::createLineTool(){
        delete this->Tool;
        Tool = new IntelliToolLine(this, &colorPicker, &Toolsettings);
}
 
void PaintingArea::createRectangleTool(){
        delete this->Tool;
        Tool = new IntelliToolRectangle(this, &colorPicker, &Toolsettings);
}
 
void PaintingArea::createCircleTool(){
        delete this->Tool;
        Tool = new IntelliToolCircle(this, &colorPicker, &Toolsettings);
}
void PaintingArea::createPolygonTool(){
        delete this->Tool;
        Tool = new IntelliToolPolygon(this, &colorPicker, &Toolsettings);
}
 
void PaintingArea::createFloodFillTool(){
        delete this->Tool;
        Tool = new IntelliToolFloodFill(this, &colorPicker, &Toolsettings);
}
 
void PaintingArea::createGradientTool(){
        delete this->Tool;
        Tool = new IntelliToolGradient(this, &colorPicker, &Toolsettings);
}
 
int PaintingArea::getWidthOfActive(){
        return this->layerBundle[static_cast<size_t>(activeLayer)].width;
}
 
int PaintingArea::getHeightOfActive(){
        return this->layerBundle[static_cast<size_t>(activeLayer)].height;
}
 
int PaintingArea::getMaxWidth(){
        return this->maxWidth;
}
 
int PaintingArea::getMaxHeight(){
        return this->maxHeight;
}
 
ImageType PaintingArea::getTypeOfImageActiveLayer(){
        return this->layerBundle[static_cast<size_t>(activeLayer)].image->getTypeOfImage();
}
 
std::vector<QPoint> PaintingArea::getPolygonDataOfActiveLayer(){
        return this->layerBundle[static_cast<size_t>(activeLayer)].image->getPolygonData();
}
 
// If a mouse button is pressed check if it was the
// left button and if so store the current position
// Set that we are currently drawing
void PaintingArea::mousePressEvent(QMouseEvent*event){
        if(this->activeLayer < 0) {
                return;
        }
        if(Tool == nullptr)
                return;
        int x = event->x() - layerBundle[static_cast<size_t>(activeLayer)].widthOffset - offsetXDimension;
        int y = event->y() - layerBundle[static_cast<size_t>(activeLayer)].heightOffset - offsetYDimension;
        if(event->button() == Qt::LeftButton) {
                Tool->onMouseLeftPressed(x, y);
        }else if(event->button() == Qt::RightButton) {
                Tool->onMouseRightPressed(x, y);
        }
        update();
}
 
// When the mouse moves if the left button is clicked
// we call the drawline function which draws a line
// from the last position to the current
void PaintingArea::mouseMoveEvent(QMouseEvent*event){
        if(this->activeLayer < 0) {
                return;
        }
        if(Tool == nullptr)
                return;
        int x = event->x() - layerBundle[static_cast<size_t>(activeLayer)].widthOffset - offsetXDimension;
        int y = event->y() - layerBundle[static_cast<size_t>(activeLayer)].heightOffset - offsetYDimension;
        Tool->onMouseMoved(x, y);
        update();
}
 
// If the button is released we set variables to stop drawing
void PaintingArea::mouseReleaseEvent(QMouseEvent*event){
        if(this->activeLayer < 0)
                return;
        if(Tool == nullptr)
                return;
        int x = event->x() - layerBundle[static_cast<size_t>(activeLayer)].widthOffset - offsetXDimension;
        int y = event->y() - layerBundle[static_cast<size_t>(activeLayer)].heightOffset - offsetYDimension;
        if(event->button() == Qt::LeftButton) {
                Tool->onMouseLeftReleased(x, y);
        }else if(event->button() == Qt::RightButton) {
                Tool->onMouseRightReleased(x, y);
        }
        update();
}
 
void PaintingArea::wheelEvent(QWheelEvent*event){
        if(this->activeLayer < 0)
                return;
        if(this->Tool != nullptr) {
                QPoint numDegrees = event->angleDelta() / 8;
                if(!numDegrees.isNull()) {
                        QPoint numSteps = numDegrees / 15;
                        Tool->onWheelScrolled(numSteps.y() * -1);
                }
        }
}
 
// QPainter provides functions to draw on the widget
// The QPaintEvent is sent to widgets that need to
// update themselves
void PaintingArea::paintEvent(QPaintEvent*event){
        this->setFixedSize(QSize(maxWidth * 2,maxHeight * 2));
        this->drawLayers();
 
        QPainter painter(this);
 
        //insert zoom factor here
        painter.scale(1,1);
 
        //calulate image here for scroll
        //Todo set offset in first to parameters and calulate them into mouse position
        painter.drawImage(0, 0, *Canvas, -offsetXDimension, -offsetYDimension);
        update();
}
 
void PaintingArea::selectLayerUp(){
        updateTools();
        if(activeLayer != -1 && static_cast<size_t>(activeLayer)<layerBundle.size() - 1) {
                std::swap(layerBundle[static_cast<size_t>(activeLayer)], layerBundle[static_cast<size_t>(activeLayer + 1)]);
                activeLayer++;
        }
}
 
void PaintingArea::selectLayerDown(){
        updateTools();
        if(activeLayer>0) {
                std::swap(layerBundle[static_cast<size_t>(activeLayer)], layerBundle[static_cast<size_t>(activeLayer - 1)]);
                activeLayer--;
        }
}
 
void PaintingArea::drawLayers(bool forSaving){
        if(forSaving) {
                Canvas->fill(Qt::GlobalColor::transparent);
        }else{
                Canvas->fill(Qt::GlobalColor::black);
        }
        for(size_t i = 0; i<layerBundle.size(); i++) {
                LayerObject layer = layerBundle[i];
                QImage cpy = layer.image->getDisplayable(layer.alpha);
                QColor clr_0;
                QColor clr_1;
                for(int y = 0; y<layer.height; y++) {
                        if(layer.heightOffset + y<0) continue;
                        if(layer.heightOffset + y>=maxHeight) break;
                        for(int x = 0; x<layer.width; x++) {
                                if(layer.widthOffset + x<0) continue;
                                if(layer.widthOffset + x>=maxWidth) break;
                                clr_0 = Canvas->pixelColor(layer.widthOffset + x, layer.heightOffset + y);
                                clr_1 = cpy.pixelColor(x,y);
                                float t = static_cast<float>(clr_1.alpha()) / 255.f;
                                int r = static_cast<int>(static_cast<float>(clr_1.red()) * (t) + static_cast<float>(clr_0.red()) * (1.f - t) + 0.5f);
                                int g = static_cast<int>(static_cast<float>(clr_1.green()) * (t) + static_cast<float>(clr_0.green()) * (1.f - t) + 0.5f);
                                int b = static_cast<int>(static_cast<float>(clr_1.blue()) * (t) + static_cast<float>(clr_0.blue() * (1.f - t)) + 0.5f);
                                int a = std::min(clr_0.alpha() + clr_1.alpha(), 255);
                                clr_0.setRed(r);
                                clr_0.setGreen(g);
                                clr_0.setBlue(b);
                                clr_0.setAlpha(a);
 
                                Canvas->setPixelColor(layer.widthOffset + x, layer.heightOffset + y, clr_0);
                        }
                }
        }
}
 
bool PaintingArea::createTempTopLayer(int idx){
        if(idx>=0) {
                LayerObject newLayer;
                newLayer.alpha = 255;
                newLayer.height = layerBundle[static_cast<size_t>(idx)].height;
                newLayer.width = layerBundle[static_cast<size_t>(idx)].width;
                newLayer.heightOffset = layerBundle[static_cast<size_t>(idx)].heightOffset;
                newLayer.widthOffset = layerBundle[static_cast<size_t>(idx)].widthOffset;
                newLayer.image = layerBundle[static_cast<size_t>(idx)].image->getDeepCopy();
                layerBundle.insert(layerBundle.begin() + idx + 1,newLayer);
                return true;
        }
        return false;
}
 
IntelliTool* PaintingArea::copyActiveTool(){
        switch(Tool->getTooltype()) {
        case IntelliTool::Tooltype::CIRCLE: return new IntelliToolCircle(this,&colorPicker, &Toolsettings);
        case IntelliTool::Tooltype::FLOODFILL: return new IntelliToolFloodFill(this,&colorPicker, &Toolsettings);
        case IntelliTool::Tooltype::GRADIENT: return new IntelliToolGradient(this,&colorPicker, &Toolsettings);
        case IntelliTool::Tooltype::LINE: return new IntelliToolLine(this,&colorPicker, &Toolsettings);
        case IntelliTool::Tooltype::PEN: return new IntelliToolPen(this,&colorPicker, &Toolsettings);
        case IntelliTool::Tooltype::PLAIN: return new IntelliToolPlainTool(this,&colorPicker, &Toolsettings);
        case IntelliTool::Tooltype::POLYGON: return new IntelliToolPolygon(this,&colorPicker, &Toolsettings);
        case IntelliTool::Tooltype::RECTANGLE: return new IntelliToolRectangle(this,&colorPicker, &Toolsettings);
        case IntelliTool::Tooltype::NONE: return nullptr;
        default: return nullptr;
        }
}
 
int PaintingArea::getIndexOfActiveLayer(){
        return activeLayer;
}
 
IntelliImage* PaintingArea::getImageOfActiveLayer(){
        if(activeLayer<0) {
                return nullptr;
        }
        return layerBundle[static_cast<size_t>(activeLayer)].image;
}
 
QImage PaintingArea::getImageDataOfActiveLayer(){
        QImage returnImage;
        if(activeLayer<0) {
                returnImage = QImage(QSize(10,10),QImage::Format_ARGB32);
                returnImage.fill(QColor(255,255,255,255));
        }
        else{
                returnImage = layerBundle[static_cast<size_t>(activeLayer)].image->getImageData();
                if(renderSettings.isFastRenderering()) {
                        returnImage = returnImage.convertToFormat(QImage::Format_ARGB32);
                }
        }
        return returnImage;
}
 
std::vector<LayerObject>* PaintingArea::getLayerBundle(){
        return &layerBundle;
}
 
void PaintingArea::updateTools(){
        if(Tool!=nullptr) {
                if(Tool->getIsDrawing()) {
                        IntelliTool* temp = copyActiveTool();
                        delete this->Tool;
                        this->Tool = temp;
                }
                if(isSettingPolygon) {
                        delete this->Tool;
                        this->Tool = nullptr;
                        isSettingPolygon = false;
                }
        }
}
 
void PaintingArea::historyadd(){
 
        history.erase(history.begin() + historyPresent + 1,history.end());
        historyPresent++;
        history.push_back(layerBundle);
}
 
void PaintingArea::historyGoBack(){
        historyPresent--;
        if( historyPresent<0) {
                historyPresent = 0;
        }
        layerBundle = history[static_cast<size_t>(historyPresent)];
        this->guiReference->UpdateGui();
}
 
void PaintingArea::historyGoForward(){
        historyPresent++;
        if(historyPresent>=static_cast<int>(history.size())) {
                historyPresent = static_cast<int>(history.size() - 1);
        }
        layerBundle = history[static_cast<size_t>(historyPresent)];
        this->guiReference->UpdateGui();
}