diff --git a/cppcheck_errors.txt b/cppcheck_errors.txt
index edc41a2..e5f712f 100644
--- a/cppcheck_errors.txt
+++ b/cppcheck_errors.txt
@@ -1,6 +1,3 @@
-src/GUI/IntelliPhotoGui.cpp:83:15: style: Variable 'layer' is assigned a value that is never used. [unreadVariable]
-    int layer = paintingArea->addLayer(width,height,0,0);
-              ^
 src/IntelliHelper/IntelliColorPicker.cpp:4:3: performance: Variable 'firstColor' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]
   firstColor = {255,0,0,255};
   ^
@@ -10,9 +7,9 @@ src/IntelliHelper/IntelliColorPicker.cpp:5:3: performance: Variable 'secondColor
 src/IntelliHelper/IntelliTriangulation.cpp:116:63: style: Parameter 'triangles' can be declared with const [constParameter]
 bool IntelliTriangulation::isInPolygon(std::vector<Triangle> &triangles, QPoint &point){
                                                               ^
-src/Layer/PaintingArea.cpp:335:22: style: Redundant condition: If 'activeLayer > 0', the comparison 'activeLayer != -1' is always true. [redundantCondition]
-  if(activeLayer!=-1 && activeLayer>0) {
-                     ^
+src/Layer/PaintingArea.cpp:334:28: style: Redundant condition: If 'activeLayer > 0', the comparison 'activeLayer != -1' is always true. [redundantCondition]
+        if(activeLayer!=-1 && activeLayer>0) {
+                           ^
 src/Tool/IntelliTool.cpp:4:14: warning: Member variable 'IntelliTool::ActiveType' is not initialized in the constructor. [uninitMemberVar]
 IntelliTool::IntelliTool(PaintingArea* Area, IntelliColorPicker* colorPicker, IntelliToolsettings* Toolsettings){
              ^
@@ -22,34 +19,31 @@ IntelliTool::IntelliTool(PaintingArea* Area, IntelliColorPicker* colorPicker, In
 src/Tool/IntelliTool.cpp:4:14: warning: Member variable 'IntelliTool::Canvas' is not initialized in the constructor. [uninitMemberVar]
 IntelliTool::IntelliTool(PaintingArea* Area, IntelliColorPicker* colorPicker, IntelliToolsettings* Toolsettings){
              ^
-src/Tool/IntelliToolCircle.cpp:43:9: style: Local variable 'yMin' shadows outer variable [shadowVariable]
+src/Tool/IntelliToolCircle.cpp:42:9: style: Local variable 'yMin' shadows outer variable [shadowVariable]
     int yMin = static_cast<int>(centerPoint.y()-sqrt(pow(radius,2)-pow(i-centerPoint.x(),2)));
         ^
-src/Tool/IntelliToolCircle.cpp:19:7: note: Shadowed declaration
+src/Tool/IntelliToolCircle.cpp:18:7: note: Shadowed declaration
   int yMin, yMax, xMin, xMax;
       ^
-src/Tool/IntelliToolCircle.cpp:43:9: note: Shadow variable
+src/Tool/IntelliToolCircle.cpp:42:9: note: Shadow variable
     int yMin = static_cast<int>(centerPoint.y()-sqrt(pow(radius,2)-pow(i-centerPoint.x(),2)));
         ^
-src/Tool/IntelliToolCircle.cpp:44:9: style: Local variable 'yMax' shadows outer variable [shadowVariable]
+src/Tool/IntelliToolCircle.cpp:43:9: style: Local variable 'yMax' shadows outer variable [shadowVariable]
     int yMax = static_cast<int>(centerPoint.y()+sqrt(pow(radius,2)-pow(i-centerPoint.x(),2)));
         ^
-src/Tool/IntelliToolCircle.cpp:19:13: note: Shadowed declaration
+src/Tool/IntelliToolCircle.cpp:18:13: note: Shadowed declaration
   int yMin, yMax, xMin, xMax;
             ^
-src/Tool/IntelliToolCircle.cpp:44:9: note: Shadow variable
+src/Tool/IntelliToolCircle.cpp:43:9: note: Shadow variable
     int yMax = static_cast<int>(centerPoint.y()+sqrt(pow(radius,2)-pow(i-centerPoint.x(),2)));
         ^
-src/Tool/IntelliToolCircle.cpp:16:13: style: Variable 'outer' is assigned a value that is never used. [unreadVariable]
-  int outer = radius+20;
-            ^
 src/Tool/IntelliToolLine.cpp:51:13: style: Variable 'c' is assigned a value that is never used. [unreadVariable]
       int c = lineStartingPoint.y()-lineStartingPoint.x()*m;
             ^
 src/Tool/IntelliToolPolygon.h:25:6: warning: The class 'IntelliToolPolygon' defines member variable with name 'isDrawing' also defined in its parent class 'IntelliTool'. [duplInheritedMember]
 bool isDrawing;
      ^
-src/Tool/IntelliTool.h:68:6: note: Parent variable 'IntelliTool::isDrawing'
+src/Tool/IntelliTool.h:69:6: note: Parent variable 'IntelliTool::isDrawing'
 bool isDrawing = false;
      ^
 src/Tool/IntelliToolPolygon.h:25:6: note: Derived variable 'IntelliToolPolygon::isDrawing'
@@ -58,34 +52,31 @@ bool isDrawing;
 src/GUI/IntelliPhotoGui.cpp:23:0: style: The function 'closeEvent' is never used. [unusedFunction]
 
 ^
-src/Layer/PaintingArea.cpp:271:0: style: The function 'mouseMoveEvent' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:261:0: style: The function 'mouseMoveEvent' is never used. [unusedFunction]
 
 ^
-src/Layer/PaintingArea.cpp:255:0: style: The function 'mousePressEvent' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:242:0: style: The function 'mousePressEvent' is never used. [unusedFunction]
 
 ^
-src/Layer/PaintingArea.cpp:281:0: style: The function 'mouseReleaseEvent' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:274:0: style: The function 'mouseReleaseEvent' is never used. [unusedFunction]
 
 ^
-src/Layer/PaintingArea.cpp:307:0: style: The function 'paintEvent' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:304:0: style: The function 'paintEvent' is never used. [unusedFunction]
 
 ^
-src/Layer/PaintingArea.cpp:318:0: style: The function 'resizeEvent' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:315:0: style: The function 'resizeEvent' is never used. [unusedFunction]
 
 ^
-src/Layer/PaintingArea.cpp:323:0: style: The function 'resizeLayer' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:320:0: style: The function 'resizeLayer' is never used. [unusedFunction]
 
 ^
-src/Layer/PaintingArea.cpp:175:0: style: The function 'slotActivateLayer' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:168:0: style: The function 'slotActivateLayer' is never used. [unusedFunction]
 
 ^
-src/GUI/IntelliPhotoGui.cpp:157:0: style: The function 'slotClearActiveLayer' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:88:0: style: The function 'slotDeleteActiveLayer' is never used. [unusedFunction]
 
 ^
-src/Layer/PaintingArea.cpp:83:0: style: The function 'slotDeleteActiveLayer' is never used. [unusedFunction]
-
-^
-src/Layer/PaintingArea.cpp:294:0: style: The function 'wheelEvent' is never used. [unusedFunction]
+src/Layer/PaintingArea.cpp:289:0: style: The function 'wheelEvent' is never used. [unusedFunction]
 
 ^
 nofile:0:0: information: Cppcheck cannot find all the include files (use --check-config for details) [missingInclude]
diff --git a/src/GUI/IntelliPhotoGui.cpp b/src/GUI/IntelliPhotoGui.cpp
index 1c4e009..c05fce8 100644
--- a/src/GUI/IntelliPhotoGui.cpp
+++ b/src/GUI/IntelliPhotoGui.cpp
@@ -46,10 +46,10 @@ void IntelliPhotoGui::slotOpen(){
 
 				// If we have a file name load the image and place
 				// it in the paintingArea
-                if (!fileName.isEmpty()){
+				if (!fileName.isEmpty()) {
 						paintingArea->open(fileName);
-                        UpdateGui();
-                }
+						UpdateGui();
+				}
 		}
 }
 
@@ -65,27 +65,52 @@ void IntelliPhotoGui::slotSave(){
 		saveFile(fileFormat);
 }
 
-// Opens a dialog that allows the user to create a New Layer
-void IntelliPhotoGui::slotCreateNewLayer(){
+// Opens a dialog that allows the user to create a New RASTER Layer
+void IntelliPhotoGui::slotCreateNewRasterLayer(){
 		// Stores button value
 		bool ok1, ok2;
 
 		// "New Layer" is the title of the window
 		// the next tr is the text to display
 		// Define the standard Value, min, max, step and ok button
-        QInputDialog Input;
-        Input.setPalette(Palette);
+		QInputDialog Input;
+		Input.setPalette(Palette);
 
-        int width = Input.getInt(this, tr("New Layer"),
-		                                 tr("Width:"),
-		                                 200,1, 500, 1, &ok1);
+		int width = Input.getInt(this, tr("New Layer"),
+		                         tr("Width:"),
+		                         200,1, 500, 1, &ok1);
 
 		int height = QInputDialog::getInt(this, tr("New Layer"),
 		                                  tr("Height:"),
 		                                  200,1, 500, 1, &ok2);
 		// Create New Layer
-		if (ok1&&ok2){
-                paintingArea->addLayer(width,height,0,0);
+		if (ok1&&ok2) {
+				paintingArea->addLayer(width,height,0,0,IntelliImage::ImageType::RASTERIMAGE);
+				UpdateGui();
+		}
+}
+
+// Opens a dialog that allows the user to create a New SHAPED Layer
+void IntelliPhotoGui::slotCreateNewShapedLayer(){
+		// Stores button value
+		bool ok1, ok2;
+
+		// "New Layer" is the title of the window
+		// the next tr is the text to display
+		// Define the standard Value, min, max, step and ok button
+		QInputDialog Input;
+		Input.setPalette(Palette);
+
+		int width = Input.getInt(this, tr("New Layer"),
+		                         tr("Width:"),
+		                         200,1, 500, 1, &ok1);
+
+		int height = QInputDialog::getInt(this, tr("New Layer"),
+		                                  tr("Height:"),
+		                                  200,1, 500, 1, &ok2);
+		// Create New Layer
+		if (ok1&&ok2) {
+				paintingArea->addLayer(width,height,0,0,IntelliImage::ImageType::SHAPEDIMAGE);
 				UpdateGui();
 		}
 }
@@ -100,10 +125,10 @@ void IntelliPhotoGui::slotDeleteLayer(){
 		// Define the standard Value, min, max, step and ok button
 		int layerNumber = QInputDialog::getInt(this, tr("delete Layer"),
 		                                       tr("Number:"),
-                                               paintingArea->getNumberOfActiveLayer()+1,1, 501, 1, &ok);
+		                                       paintingArea->getNumberOfActiveLayer()+1,1, 501, 1, &ok);
 		// Create New Layer
 		if (ok) {
-                paintingArea->deleteLayer(layerNumber-1);
+				paintingArea->deleteLayer(layerNumber-1);
 				UpdateGui();
 		}
 }
@@ -117,14 +142,32 @@ void IntelliPhotoGui::slotSetActiveAlpha(){
 		// Define the standard Value, min, max, step and ok button
 		int layer = QInputDialog::getInt(this, tr("Layer to set on"),
 		                                 tr("Layer:"),
-                                         1,1,500,1, &ok1);
+		                                 1,1,500,1, &ok1);
 		// "New Alpha" is the title of the window
 		int alpha = QInputDialog::getInt(this, tr("New Alpha"),
 		                                 tr("Alpha:"),
 		                                 255,0, 255, 1, &ok2);
 		if (ok1&&ok2)
 		{
-                paintingArea->setLayerAlpha(layer-1,alpha);
+				paintingArea->setLayerAlpha(layer-1,alpha);
+				UpdateGui();
+		}
+}
+
+void IntelliPhotoGui::slotSetPolygon(){
+		// Stores button value
+		bool ok1;
+
+		// "Layer to set on" is the title of the window
+		// the next tr is the text to display
+		// Define the standard Value, min, max, step and ok button
+		int layer = QInputDialog::getInt(this, tr("Layer to set on"),
+		                                 tr("Layer:"),
+		                                 1,1,500,1, &ok1);
+
+		if (ok1)
+		{
+				paintingArea->setPolygon(layer-1);
 				UpdateGui();
 		}
 }
@@ -159,60 +202,31 @@ void IntelliPhotoGui::slotMoveLayerDown(){
 		update();
 }
 
-void IntelliPhotoGui::slotClearActiveLayer(){
-		// Stores button value
-		bool ok1, ok2, ok3, ok4;
-
-		// "Red Input" is the title of the window
-		// the next tr is the text to display
-		// Define the standard Value, min, max, step and ok button
-		int red = QInputDialog::getInt(this, tr("Red Input"),
-		                               tr("Red:"),
-		                               255,0, 255,1, &ok1);
-		// "Green Input" is the title of the window
-		int green = QInputDialog::getInt(this, tr("Green Input"),
-		                                 tr("Green:"),
-		                                 255,0, 255, 1, &ok2);
-		// "Blue Input" is the title of the window
-		int blue = QInputDialog::getInt(this, tr("Blue Input"),
-		                                tr("Blue:"),
-		                                255,0, 255, 1, &ok3);
-		// "Alpha Input" is the title of the window
-		int alpha = QInputDialog::getInt(this, tr("Alpha Input"),
-		                                 tr("Alpha:"),
-		                                 255,0, 255, 1, &ok4);
-		if (ok1&&ok2&&ok3&&ok4)
-		{
-				paintingArea->floodFill(red, green, blue, alpha);
-				UpdateGui();
-		}
-}
-
 void IntelliPhotoGui::slotSetActiveLayer(){
 		// Stores button value
 		bool ok1;
 
 		// "Layer to set on" is the title of the window
 		// the next tr is the text to display
-        // Define the standard Value, min, max, step and ok button
-        int layer = QInputDialog::getInt(this, tr("Layer to set on"),
-                                         tr("Layer:"),
-                                         1,1,500,1, &ok1);
-        if (ok1)
+		// Define the standard Value, min, max, step and ok button
+		int layer = QInputDialog::getInt(this, tr("Layer to set on"),
+		                                 tr("Layer:"),
+		                                 1,1,500,1, &ok1);
+		if (ok1)
 		{
-                paintingArea->setLayerActive(layer-1);
+				paintingArea->setLayerActive(layer-1);
 				UpdateGui();
 		}
 }
 
 void IntelliPhotoGui::slotUpdateRenderSettingsOn(){
-        paintingArea->setRenderSettings(true);
-        UpdateGui();
+		paintingArea->setRenderSettings(true);
+		UpdateGui();
 }
 
 void IntelliPhotoGui::slotUpdateRenderSettingsOff(){
-        paintingArea->setRenderSettings(false);
-        UpdateGui();
+		paintingArea->setRenderSettings(false);
+		UpdateGui();
 }
 
 void IntelliPhotoGui::slotSetFirstColor(){
@@ -269,7 +283,7 @@ void IntelliPhotoGui::slotCreateFloodFillTool(){
 void IntelliPhotoGui::slotAboutDialog(){
 		// Window title and text to display
 		QMessageBox::about(this, tr("About Painting"),
-                           tr("<p><b>IntelliPhoto - </b>A Pretty basic editor.</p> <br>Developed by Team 7."));
+		                   tr("<p><b>IntelliPhoto - </b>A Pretty basic editor.</p> <br>Developed by Team 7."));
 }
 
 void IntelliPhotoGui::slotEnterPressed(){
@@ -296,13 +310,13 @@ void IntelliPhotoGui::slotResetTools(){
 }
 
 void IntelliPhotoGui::slotSetWidth(){
-    paintingArea->Toolsettings.setLineWidth();
-    EditLineWidth->setText(QString("%1").arg(paintingArea->Toolsettings.getLineWidth()));
+		paintingArea->Toolsettings.setLineWidth();
+		EditLineWidth->setText(QString("%1").arg(paintingArea->Toolsettings.getLineWidth()));
 }
 
 void IntelliPhotoGui::slotSetInnerAlpha(){
-    paintingArea->Toolsettings.setInnerAlpha();
-    EditLineInnerAlpha->setText(QString("%1").arg(paintingArea->Toolsettings.getInnerAlpha()));
+		paintingArea->Toolsettings.setInnerAlpha();
+		EditLineInnerAlpha->setText(QString("%1").arg(paintingArea->Toolsettings.getInnerAlpha()));
 }
 
 // Define menu actions that call functions
@@ -332,7 +346,7 @@ void IntelliPhotoGui::createActions(){
 		connect(pngSaveAction, SIGNAL(triggered()), this, SLOT(slotSave()));
 		// Attach each PNG in save Menu
 		actionSaveAs.append(pngSaveAction);
-        pngSaveAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_S));
+		pngSaveAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_S));
 
 		// Create exit action and tie to IntelliPhotoGui::close()
 		actionExit = new QAction(tr("&Exit"), this);
@@ -343,24 +357,34 @@ void IntelliPhotoGui::createActions(){
 		actionOpen->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_O));
 		connect(actionOpen, SIGNAL(triggered()), this, SLOT(slotOpen()));
 
-		// Create New Layer action and tie to IntelliPhotoGui::newLayer()
-		actionCreateNewLayer = new QAction(tr("&New Layer..."), this);
-		actionCreateNewLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_N));
-		connect(actionCreateNewLayer, SIGNAL(triggered()), this, SLOT(slotCreateNewLayer()));
+		// Create New RASTER Layer action and tie to IntelliPhotoGui::newLayer()
+		actionCreateNewRasterLayer = new QAction(tr("&Raster Image"), this);
+		actionCreateNewRasterLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_N));
+		connect(actionCreateNewRasterLayer, SIGNAL(triggered()), this, SLOT(slotCreateNewRasterLayer()));
+
+
+		// Create New SHAPED Layer action and tie to IntelliPhotoGui::newLayer()
+		actionCreateNewShapedLayer = new QAction(tr("&Shaped Image"), this);
+		actionCreateNewShapedLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_N + Qt::ALT));
+		connect(actionCreateNewShapedLayer, SIGNAL(triggered()), this, SLOT(slotCreateNewShapedLayer()));
 
 		// Delete New Layer action and tie to IntelliPhotoGui::deleteLayer()
 		actionDeleteLayer = new QAction(tr("&Delete Layer..."), this);
-        actionDeleteLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_D));
+		actionDeleteLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_D));
 		connect(actionDeleteLayer, SIGNAL(triggered()), this, SLOT(slotDeleteLayer()));
 
 		actionSetActiveLayer = new QAction(tr("&set Active"), this);
-        actionSetActiveLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_A));
+		actionSetActiveLayer->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_A));
 		connect(actionSetActiveLayer, SIGNAL(triggered()), this, SLOT(slotSetActiveLayer()));
 
-        actionSetActiveAlpha = new QAction(tr("&set Alpha"), this);
-        actionSetActiveAlpha->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_A));
+		actionSetActiveAlpha = new QAction(tr("&set Alpha"), this);
+		actionSetActiveAlpha->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_A));
 		connect(actionSetActiveAlpha, SIGNAL(triggered()), this, SLOT(slotSetActiveAlpha()));
 
+		actionSetPolygon = new QAction(tr("&set new Polygondata"), this);
+		actionSetPolygon->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_P));
+		connect(actionSetPolygon, SIGNAL(triggered()), this, SLOT(slotSetPolygon()));
+
 		actionMovePositionUp = new QAction(tr("&move Up"), this);
 		actionMovePositionUp->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Up));
 		connect(actionMovePositionUp, SIGNAL(triggered()), this, SLOT(slotPositionMoveUp()));
@@ -385,76 +409,76 @@ void IntelliPhotoGui::createActions(){
 		actionMoveLayerDown->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_Down));
 		connect(actionMoveLayerDown, SIGNAL(triggered()), this, SLOT(slotMoveLayerDown()));
 
-        //Create Update RenderSettings Actions here
-        actionUpdateRenderSettingsOn = new QAction(tr("&On"), this);
-        actionUpdateRenderSettingsOn->setShortcut(QKeySequence(Qt::ALT +Qt::SHIFT + +Qt::Key_A));
-        connect(actionUpdateRenderSettingsOn, SIGNAL(triggered()),this, SLOT(slotUpdateRenderSettingsOn()));
+		//Create Update RenderSettings Actions here
+		actionUpdateRenderSettingsOn = new QAction(tr("&On"), this);
+		actionUpdateRenderSettingsOn->setShortcut(QKeySequence(Qt::ALT +Qt::SHIFT + +Qt::Key_A));
+		connect(actionUpdateRenderSettingsOn, SIGNAL(triggered()),this, SLOT(slotUpdateRenderSettingsOn()));
 
-        actionUpdateRenderSettingsOff = new QAction(tr("&Off"), this);
-        actionUpdateRenderSettingsOff->setShortcut(QKeySequence(Qt::ALT +Qt::SHIFT + +Qt::Key_D));
-        connect(actionUpdateRenderSettingsOff, SIGNAL(triggered()),this, SLOT(slotUpdateRenderSettingsOff()));
+		actionUpdateRenderSettingsOff = new QAction(tr("&Off"), this);
+		actionUpdateRenderSettingsOff->setShortcut(QKeySequence(Qt::ALT +Qt::SHIFT + +Qt::Key_D));
+		connect(actionUpdateRenderSettingsOff, SIGNAL(triggered()),this, SLOT(slotUpdateRenderSettingsOff()));
 
 		//Create Color Actions here
 		actionColorPickerFirstColor = new QAction(tr("&Main"), this);
-        actionColorPickerFirstColor->setShortcut(QKeySequence(Qt::ALT + Qt::Key_N));
+		actionColorPickerFirstColor->setShortcut(QKeySequence(Qt::ALT + Qt::Key_N));
 		connect(actionColorPickerFirstColor, SIGNAL(triggered()), this, SLOT(slotSetFirstColor()));
 		connect(FirstColorButton, SIGNAL(clicked()), this, SLOT(slotSetFirstColor()));
 
 		actionColorPickerSecondColor = new QAction(tr("&Secondary"), this);
-        actionColorPickerSecondColor->setShortcut(QKeySequence(Qt::ALT + Qt::Key_M));
+		actionColorPickerSecondColor->setShortcut(QKeySequence(Qt::ALT + Qt::Key_M));
 		connect(actionColorPickerSecondColor, SIGNAL(triggered()), this, SLOT(slotSetSecondColor()));
 		connect(SecondColorButton, SIGNAL(clicked()), this, SLOT(slotSetSecondColor()));
 
 		actionColorSwap = new QAction(tr("&Switch"), this);
-        actionColorSwap->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_S));
+		actionColorSwap->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_S));
 		connect(actionColorSwap, SIGNAL(triggered()), this, SLOT(slotSwapColor()));
 		connect(SwitchColorButton, SIGNAL(clicked()), this, SLOT(slotSwapColor()));
 
 		//Create Tool actions down here
 		actionCreatePlainTool = new QAction(tr("&Plain"), this);
-        actionCreatePlainTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_P));
+		actionCreatePlainTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_P));
 		connect(actionCreatePlainTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
 		connect(actionCreatePlainTool, SIGNAL(triggered()), this, SLOT(slotCreatePlainTool()));
 
 
 		actionCreatePenTool = new QAction(tr("&Pen"),this);
-        actionCreatePenTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_S));
+		actionCreatePenTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_S));
 		connect(actionCreatePenTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
 		connect(actionCreatePenTool, SIGNAL(triggered()), this, SLOT(slotCreatePenTool()));
 
 		actionCreateLineTool = new QAction(tr("&Line"), this);
-        actionCreateLineTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_L));
+		actionCreateLineTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_L));
 		connect(actionCreateLineTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
 		connect(actionCreateLineTool, SIGNAL(triggered()), this, SLOT(slotCreateLineTool()));
 
 		actionCreateCircleTool = new QAction(tr("&Circle"), this);
-        actionCreateCircleTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_C));
+		actionCreateCircleTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_C));
 		connect(actionCreateCircleTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
 		connect(actionCreateCircleTool, SIGNAL(triggered()), this, SLOT(slotCreateCircleTool()));
 
 		actionCreateRectangleTool = new QAction(tr("&Rectangle"), this);
-        actionCreateRectangleTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_R));
+		actionCreateRectangleTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_R));
 		connect(actionCreateRectangleTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
 		connect(actionCreateRectangleTool, SIGNAL(triggered()), this, SLOT(slotCreateRectangleTool()));
 
 		actionCreatePolygonTool = new QAction(tr("&Polygon"), this);
-        actionCreatePolygonTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_V));
+		actionCreatePolygonTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_V));
 		connect(actionCreatePolygonTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
 		connect(actionCreatePolygonTool, SIGNAL(triggered()), this, SLOT(slotCreatePolygonTool()));
 
 		actionCreateFloodFillTool = new QAction(tr("&FloodFill"), this);
-        actionCreateFloodFillTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_F));
+		actionCreateFloodFillTool->setShortcut(QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT +Qt::Key_F));
 		connect(actionCreateFloodFillTool, SIGNAL(triggered()), this, SLOT(slotResetTools()));
 		connect(actionCreateFloodFillTool, SIGNAL(triggered()), this, SLOT(slotCreateFloodFillTool()));
 
 		// Create about action and tie to IntelliPhotoGui::about()
 		actionAboutDialog = new QAction(tr("&About"), this);
-        actionAboutDialog->setShortcut(Qt::Key_F2);
+		actionAboutDialog->setShortcut(Qt::Key_F2);
 		connect(actionAboutDialog, SIGNAL(triggered()), this, SLOT(slotAboutDialog()));
 
 		// Create about Qt action and tie to IntelliPhotoGui::aboutQt()
 		actionAboutQtDialog = new QAction(tr("About &Qt"), this);
-        actionAboutQtDialog->setShortcut(Qt::Key_F3);
+		actionAboutQtDialog->setShortcut(Qt::Key_F3);
 		connect(actionAboutQtDialog, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
 
 		connect(EditLineWidth, SIGNAL(returnPressed()), this, SLOT(slotEnterPressed()));
@@ -481,13 +505,13 @@ void IntelliPhotoGui::createActions(){
 		connect(RectangleButton,SIGNAL(pressed()), this, SLOT(slotResetTools()));
 		connect(RectangleButton, SIGNAL(clicked()), this, SLOT(slotCreateRectangleTool()));
 
-        actionSetWidth = new QAction(tr("&Set Width"),this);
-        actionSetWidth->setShortcut(QKeySequence(Qt::ALT + Qt::Key_W));
-        connect(actionSetWidth, SIGNAL(triggered()), this, SLOT(slotSetWidth()));
+		actionSetWidth = new QAction(tr("&Set Width"),this);
+		actionSetWidth->setShortcut(QKeySequence(Qt::ALT + Qt::Key_W));
+		connect(actionSetWidth, SIGNAL(triggered()), this, SLOT(slotSetWidth()));
 
-        actionSetInnerAlpha = new QAction(tr("&Set Inner Alpha"),this);
-        actionSetInnerAlpha->setShortcut(QKeySequence(Qt::ALT + Qt::Key_A));
-        connect(actionSetInnerAlpha, SIGNAL(triggered()), this, SLOT(slotSetInnerAlpha()));
+		actionSetInnerAlpha = new QAction(tr("&Set Inner Alpha"),this);
+		actionSetInnerAlpha->setShortcut(QKeySequence(Qt::ALT + Qt::Key_A));
+		connect(actionSetInnerAlpha, SIGNAL(triggered()), this, SLOT(slotSetInnerAlpha()));
 }
 
 // Create the menubar
@@ -505,61 +529,66 @@ void IntelliPhotoGui::createMenus(){
 		fileMenu->addSeparator();
 		fileMenu->addAction(actionExit);
 
-        //Attach all actions to Render Settings
-        renderMenu = new QMenu(tr("&Fast Renderer"), this);
-        renderMenu->addAction(actionUpdateRenderSettingsOn);
-        renderMenu->addAction(actionUpdateRenderSettingsOff);
+		//Attach all actions to Render Settings
+		renderMenu = new QMenu(tr("&Fast Renderer"), this);
+		renderMenu->addAction(actionUpdateRenderSettingsOn);
+		renderMenu->addAction(actionUpdateRenderSettingsOff);
 
-        // Attach all actions to Layer
-        layerMenu = new QMenu(tr("&Layer"), this);
-        layerMenu->addAction(actionCreateNewLayer);
-        layerMenu->addSeparator();
-        layerMenu->addAction(actionSetActiveAlpha);
-        layerMenu->addAction(actionSetActiveLayer);
-        layerMenu->addSeparator();
-        layerMenu->addAction(actionMovePositionUp);
-        layerMenu->addAction(actionMovePositionDown);
-        layerMenu->addAction(actionMovePositionLeft);
-        layerMenu->addAction(actionMovePositionRight);
-        layerMenu->addAction(actionMoveLayerUp);
-        layerMenu->addAction(actionMoveLayerDown);
-        layerMenu->addSeparator();
-        layerMenu->addAction(actionDeleteLayer);
+		//Attach all Layer Creations to Menu
+		layerCreationMenu = new QMenu(tr("&Create new Layer"), this);
+		layerCreationMenu->addAction(actionCreateNewRasterLayer);
+		layerCreationMenu->addAction(actionCreateNewShapedLayer);
+		// Attach all actions to Layer
+		layerMenu = new QMenu(tr("&Layer"), this);
+		layerMenu->addMenu(layerCreationMenu);
+		layerMenu->addSeparator();
+		layerMenu->addAction(actionSetActiveAlpha);
+		layerMenu->addAction(actionSetActiveLayer);
+		layerMenu->addAction(actionSetPolygon);
+		layerMenu->addSeparator();
+		layerMenu->addAction(actionMovePositionUp);
+		layerMenu->addAction(actionMovePositionDown);
+		layerMenu->addAction(actionMovePositionLeft);
+		layerMenu->addAction(actionMovePositionRight);
+		layerMenu->addAction(actionMoveLayerUp);
+		layerMenu->addAction(actionMoveLayerDown);
+		layerMenu->addSeparator();
+		layerMenu->addAction(actionDeleteLayer);
 
-        //Attach all Color Options
-        colorMenu = new QMenu(tr("&Color"), this);
-        colorMenu->addAction(actionColorPickerFirstColor);
-        colorMenu->addAction(actionColorPickerSecondColor);
-        colorMenu->addAction(actionColorSwap);
+		//Attach all Color Options
+		colorMenu = new QMenu(tr("&Color"), this);
+		colorMenu->addAction(actionColorPickerFirstColor);
+		colorMenu->addAction(actionColorPickerSecondColor);
+		colorMenu->addAction(actionColorSwap);
 
-        //Attach all Tool Creation Actions
-        toolCreationMenu = new QMenu(tr("&Drawingtools"), this);
-        toolCreationMenu->addAction(actionCreateCircleTool);
-        toolCreationMenu->addAction(actionCreateFloodFillTool);
-        toolCreationMenu->addAction(actionCreateLineTool);
-        toolCreationMenu->addAction(actionCreatePenTool);
-        toolCreationMenu->addAction(actionCreatePlainTool);
-        toolCreationMenu->addAction(actionCreatePolygonTool);
-        toolCreationMenu->addAction(actionCreateRectangleTool);
+		//Attach all Tool Creation Actions
+		toolCreationMenu = new QMenu(tr("&Drawingtools"), this);
+		toolCreationMenu->addAction(actionCreateCircleTool);
+		toolCreationMenu->addAction(actionCreateFloodFillTool);
+		toolCreationMenu->addAction(actionCreateLineTool);
+		toolCreationMenu->addAction(actionCreatePenTool);
+		toolCreationMenu->addAction(actionCreatePlainTool);
+		toolCreationMenu->addAction(actionCreatePolygonTool);
+		toolCreationMenu->addAction(actionCreateRectangleTool);
 
-        //Attach all Tool Setting Actions
-        toolSettingsMenu = new QMenu(tr("&Toolsettings"), this);
-        toolSettingsMenu->addAction(actionSetWidth);
-        toolSettingsMenu->addAction(actionSetInnerAlpha);
+		//Attach all Tool Setting Actions
+		toolSettingsMenu = new QMenu(tr("&Toolsettings"), this);
+		toolSettingsMenu->addAction(actionSetWidth);
+		toolSettingsMenu->addAction(actionSetInnerAlpha);
 
-        //Attach all Tool Options
-        toolMenu = new QMenu(tr("&Tools"), this);
-        toolMenu->addMenu(toolCreationMenu);
-        toolMenu->addMenu(toolSettingsMenu);
-        toolMenu->addSeparator();
-        toolMenu->addMenu(colorMenu);
+		//Attach all Tool Options
+		toolMenu = new QMenu(tr("&Tools"), this);
+		toolMenu->addMenu(toolCreationMenu);
+		toolMenu->addMenu(toolSettingsMenu);
+		toolMenu->addSeparator();
+		toolMenu->addMenu(colorMenu);
 
 		// Attach all actions to Options
 		optionMenu = new QMenu(tr("&Options"), this);
-        optionMenu->addMenu(layerMenu);
-        optionMenu->addMenu(toolMenu);
-        optionMenu->addSeparator();
-        optionMenu->addMenu(renderMenu);
+		optionMenu->addMenu(layerMenu);
+		optionMenu->addMenu(toolMenu);
+		optionMenu->addSeparator();
+		optionMenu->addMenu(renderMenu);
 
 		// Attach all actions to Help
 		helpMenu = new QMenu(tr("&Help"), this);
@@ -583,54 +612,54 @@ void IntelliPhotoGui::createGui(){
 
 		// create Gui elements
 		paintingArea = new PaintingArea();
-        paintingArea->DummyGui = this;
+		paintingArea->DummyGui = this;
 
-        preview = QPixmap(":/Icons/Buttons/icons/circle-tool.svg");
+		preview = QPixmap(":/Icons/Buttons/icons/circle-tool.svg");
 		CircleButton = new QPushButton();
 		CircleButton->setFixedSize(Buttonsize);
-        CircleButton->setIcon(preview);
+		CircleButton->setIcon(preview);
 		CircleButton->setIconSize(Buttonsize);
 		CircleButton->setCheckable(true);
 
-        preview = QPixmap(":/Icons/Buttons/icons/flood-fill-tool.svg");
+		preview = QPixmap(":/Icons/Buttons/icons/flood-fill-tool.svg");
 		FloodFillButton = new QPushButton();
 		FloodFillButton->setFixedSize(Buttonsize);
-        FloodFillButton->setIcon(preview);
+		FloodFillButton->setIcon(preview);
 		FloodFillButton->setIconSize(Buttonsize);
 		FloodFillButton->setCheckable(true);
 
-        preview = QPixmap(":/Icons/Buttons/icons/line-tool.svg");
+		preview = QPixmap(":/Icons/Buttons/icons/line-tool.svg");
 		LineButton = new QPushButton();
 		LineButton->setFixedSize(Buttonsize);
-        LineButton->setIcon(preview);
+		LineButton->setIcon(preview);
 		LineButton->setIconSize(Buttonsize);
 		LineButton->setCheckable(true);
 
-        preview = QPixmap(":/Icons/Buttons/icons/pen-tool.svg");
+		preview = QPixmap(":/Icons/Buttons/icons/pen-tool.svg");
 		PenButton = new QPushButton();
 		PenButton->setFixedSize(Buttonsize);
-        PenButton->setIcon(preview);
+		PenButton->setIcon(preview);
 		PenButton->setIconSize(Buttonsize);
 		PenButton->setCheckable(true);
 
-        preview = QPixmap(":/Icons/Buttons/icons/plain-tool.svg");
+		preview = QPixmap(":/Icons/Buttons/icons/plain-tool.svg");
 		PlainButton = new QPushButton();
 		PlainButton->setFixedSize(Buttonsize);
-        PlainButton->setIcon(preview);
+		PlainButton->setIcon(preview);
 		PlainButton->setIconSize(Buttonsize);
 		PlainButton->setCheckable(true);
 
-        preview = QPixmap(":/Icons/Buttons/icons/polygon-tool.svg");
+		preview = QPixmap(":/Icons/Buttons/icons/polygon-tool.svg");
 		PolygonButton = new QPushButton();
 		PolygonButton->setFixedSize(Buttonsize);
-        PolygonButton->setIcon(preview);
+		PolygonButton->setIcon(preview);
 		PolygonButton->setIconSize(Buttonsize);
 		PolygonButton->setCheckable(true);
 
-        preview = QPixmap(":/Icons/Buttons/icons/rectangle-tool.svg");
+		preview = QPixmap(":/Icons/Buttons/icons/rectangle-tool.svg");
 		RectangleButton = new QPushButton();
 		RectangleButton->setFixedSize(Buttonsize);
-        RectangleButton->setIcon(preview);
+		RectangleButton->setIcon(preview);
 		RectangleButton->setIconSize(Buttonsize);
 		RectangleButton->setCheckable(true);
 
@@ -664,29 +693,29 @@ void IntelliPhotoGui::createGui(){
 		SecondColorButton = new QPushButton();
 		SecondColorButton->setFixedSize(Buttonsize/2);
 
-        preview = QPixmap(":/Icons/Buttons/icons/Wechselpfeile.png");
+		preview = QPixmap(":/Icons/Buttons/icons/Wechselpfeile.png");
 		SwitchColorButton = new QPushButton();
 		SwitchColorButton->setFixedSize(Buttonsize.width(),Buttonsize.height()/2);
-        SwitchColorButton->setIcon(preview);
+		SwitchColorButton->setIcon(preview);
 		SwitchColorButton->setIconSize(QSize(Buttonsize.width(),Buttonsize.height()/2));
 
 		ActiveLayerLine = new QLabel();
-        QString string = QString("Active Layer: %1").arg(paintingArea->getNumberOfActiveLayer() + 1);
+		QString string = QString("Active Layer: %1").arg(paintingArea->getNumberOfActiveLayer() + 1);
 		ActiveLayerLine->setText(string);
 		ActiveLayerLine->setFixedSize(Buttonsize.width()+10,Buttonsize.height()/3);
 
-        IntelliImage* activePicture = paintingArea->getImageOfActiveLayer();
-        if(activePicture){
-            preview = preview.fromImage(activePicture->getImageData());
-        }else{
-            QImage tmp(1,1,QImage::Format_ARGB32);
-            tmp.fill(Qt::transparent);
-            preview = preview.fromImage(tmp);
-        }
+		IntelliImage* activePicture = paintingArea->getImageOfActiveLayer();
+		if(activePicture) {
+				preview = preview.fromImage(activePicture->getImageData());
+		}else{
+				QImage tmp(1,1,QImage::Format_ARGB32);
+				tmp.fill(Qt::transparent);
+				preview = preview.fromImage(tmp);
+		}
 
-        ActiveLayerImageLine = new QLabel();
-        ActiveLayerImageLine->setFixedSize(Buttonsize);
-        ActiveLayerImageLine->setPixmap(preview.scaled(Buttonsize));
+		ActiveLayerImageLine = new QLabel();
+		ActiveLayerImageLine->setFixedSize(Buttonsize);
+		ActiveLayerImageLine->setPixmap(preview.scaled(Buttonsize));
 
 		// set gui elements
 
@@ -706,40 +735,41 @@ void IntelliPhotoGui::createGui(){
 		mainLayout->addWidget(SecondColorButton,12,3,1,1);
 		mainLayout->addWidget(SwitchColorButton,13,2,1,2);
 		mainLayout->addWidget(ActiveLayerLine,14,2,1,2);
-        mainLayout->addWidget(ActiveLayerImageLine,15,2,1,2);
+		mainLayout->addWidget(ActiveLayerImageLine,15,2,1,2);
 }
 
 void IntelliPhotoGui::setIntelliStyle(){
 		// Set the title
 		setWindowTitle("IntelliPhoto Prototype");
-        Palette.setBrush(QPalette::HighlightedText, QColor(200, 10, 10));
-        Palette.setBrush(QPalette::Highlight, QColor(100, 5, 5));
-        Palette.setBrush(QPalette::ButtonText, QColor(255, 255, 255));
-        Palette.setBrush(QPalette::Button, QColor(64, 64, 64));
-        Palette.setBrush(QPalette::Window, QColor(0, 0, 0));
-        Palette.setBrush(QPalette::WindowText, QColor(255, 255, 255));
-        Palette.setBrush(QPalette::PlaceholderText, QColor(255, 255, 255));
-        Palette.setBrush(QPalette::ToolTipText, QColor(255, 255, 255));
-        Palette.setBrush(QPalette::Text, QColor(255, 255, 255));
+		Palette.setBrush(QPalette::HighlightedText, QColor(200, 10, 10));
+		Palette.setBrush(QPalette::Highlight, QColor(100, 5, 5));
+		Palette.setBrush(QPalette::ButtonText, QColor(255, 255, 255));
+		Palette.setBrush(QPalette::Button, QColor(64, 64, 64));
+		Palette.setBrush(QPalette::Window, QColor(0, 0, 0));
+		Palette.setBrush(QPalette::WindowText, QColor(255, 255, 255));
+		Palette.setBrush(QPalette::PlaceholderText, QColor(255, 255, 255));
+		Palette.setBrush(QPalette::ToolTipText, QColor(255, 255, 255));
+		Palette.setBrush(QPalette::Text, QColor(255, 255, 255));
 		// Set style sheet
-        this->setStyleSheet("background-color:rgb(64,64,64)");
-        this->menuBar()->setPalette(Palette);
-        this->fileMenu->setPalette(Palette);
-        this->saveAsMenu->setPalette(Palette);
-        this->optionMenu->setPalette(Palette);
-        this->helpMenu->setPalette(Palette);
-        this->renderMenu->setPalette(Palette);
-        this->toolMenu->setPalette(Palette);
-        this->layerMenu->setPalette(Palette);
-        this->colorMenu->setPalette(Palette);
-        this->toolCreationMenu->setPalette(Palette);
-        this->toolSettingsMenu->setPalette(Palette);
+		this->setStyleSheet("background-color:rgb(64,64,64)");
+		this->menuBar()->setPalette(Palette);
+		this->fileMenu->setPalette(Palette);
+		this->saveAsMenu->setPalette(Palette);
+		this->optionMenu->setPalette(Palette);
+		this->helpMenu->setPalette(Palette);
+		this->renderMenu->setPalette(Palette);
+		this->toolMenu->setPalette(Palette);
+		this->layerCreationMenu->setPalette(Palette);
+		this->layerMenu->setPalette(Palette);
+		this->colorMenu->setPalette(Palette);
+		this->toolCreationMenu->setPalette(Palette);
+		this->toolSettingsMenu->setPalette(Palette);
 
-        this->WidthLine->setPalette(Palette);
-        this->EditLineWidth->setPalette(Palette);
-        this->innerAlphaLine->setPalette(Palette);
-        this->EditLineInnerAlpha->setPalette(Palette);
-        this->ActiveLayerLine->setPalette(Palette);
+		this->WidthLine->setPalette(Palette);
+		this->EditLineWidth->setPalette(Palette);
+		this->innerAlphaLine->setPalette(Palette);
+		this->EditLineInnerAlpha->setPalette(Palette);
+		this->ActiveLayerLine->setPalette(Palette);
 
 		QString string = QString("background-color: %1").arg(paintingArea->colorPicker.getFirstColor().name());
 		FirstColorButton->setStyleSheet(string);
@@ -800,18 +830,18 @@ void IntelliPhotoGui::setDefaultToolValue(){
 }
 
 void IntelliPhotoGui::UpdateGui(){
-        QString string = QString("Active Layer: %1").arg(paintingArea->getNumberOfActiveLayer() + 1);
+		QString string = QString("Active Layer: %1").arg(paintingArea->getNumberOfActiveLayer() + 1);
 		ActiveLayerLine->setText(string);
 
-        IntelliImage* activePicture = paintingArea->getImageOfActiveLayer();
-        if(activePicture){
-            preview = preview.fromImage(activePicture->getImageData());
-        }else{
-            QImage tmp(1,1,QImage::Format_ARGB32);
-            tmp.fill(Qt::transparent);
-            preview = preview.fromImage(tmp);
-        }
-        ActiveLayerImageLine->setPixmap(preview.scaled(Buttonsize));
+		IntelliImage* activePicture = paintingArea->getImageOfActiveLayer();
+		if(activePicture) {
+				preview = preview.fromImage(activePicture->getImageData());
+		}else{
+				QImage tmp(1,1,QImage::Format_ARGB32);
+				tmp.fill(Qt::transparent);
+				preview = preview.fromImage(tmp);
+		}
+		ActiveLayerImageLine->setPixmap(preview.scaled(Buttonsize));
 
 		string = QString("background-color: %1").arg(paintingArea->colorPicker.getFirstColor().name());
 		FirstColorButton->setStyleSheet(string);
diff --git a/src/GUI/IntelliPhotoGui.h b/src/GUI/IntelliPhotoGui.h
index 6dd85f2..25decab 100644
--- a/src/GUI/IntelliPhotoGui.h
+++ b/src/GUI/IntelliPhotoGui.h
@@ -25,7 +25,7 @@ class IntelliColorPicker;
  * \brief The IntelliPhotoGui class handles the graphical user interface for the intelliPhoto program
  */
 class IntelliPhotoGui : public QMainWindow {
-    friend UnitTest;
+friend UnitTest;
 // Declares our class as a QObject which is the base class
 // for all Qt objects
 // QObjects handle events
@@ -48,11 +48,12 @@ void slotOpen();
 void slotSave();
 
 // layer slots here
-void slotCreateNewLayer();
+void slotCreateNewRasterLayer();
+void slotCreateNewShapedLayer();
 void slotDeleteLayer();
-void slotClearActiveLayer();
 void slotSetActiveLayer();
 void slotSetActiveAlpha();
+void slotSetPolygon();
 void slotPositionMoveUp();
 void slotPositionMoveDown();
 void slotPositionMoveLeft();
@@ -133,16 +134,17 @@ QLabel* ActiveLayerImageLine;
 QPalette Palette;
 
 // The menu widgets
-QMenu* saveAsMenu;
-QMenu* fileMenu;
-QMenu* renderMenu;
-QMenu* optionMenu;
-QMenu* layerMenu;
-QMenu* colorMenu;
-QMenu* toolCreationMenu;
-QMenu* toolSettingsMenu;
-QMenu* toolMenu;
-QMenu* helpMenu;
+QMenu*saveAsMenu;
+QMenu*fileMenu;
+QMenu*renderMenu;
+QMenu*optionMenu;
+QMenu*layerCreationMenu;
+QMenu*layerMenu;
+QMenu*colorMenu;
+QMenu*toolCreationMenu;
+QMenu*toolSettingsMenu;
+QMenu*toolMenu;
+QMenu*helpMenu;
 
 // All the actions that can occur
 // meta image actions (need further modularisation)
@@ -172,10 +174,12 @@ QAction* actionAboutDialog;
 QAction* actionAboutQtDialog;
 
 // layer change actions
-QAction* actionCreateNewLayer;
+QAction* actionCreateNewRasterLayer;
+QAction* actionCreateNewShapedLayer;
 QAction* actionDeleteLayer;
 QAction* actionSetActiveLayer;
 QAction* actionSetActiveAlpha;
+QAction* actionSetPolygon;
 QAction* actionMovePositionUp;
 QAction* actionMovePositionDown;
 QAction* actionMovePositionLeft;
diff --git a/src/Image/IntelliImage.cpp b/src/Image/IntelliImage.cpp
index 042e01f..0017877 100644
--- a/src/Image/IntelliImage.cpp
+++ b/src/Image/IntelliImage.cpp
@@ -3,15 +3,15 @@
 #include <QPainter>
 
 IntelliImage::IntelliImage(int width, int height, bool fastRendererOn)
-        : imageData(QSize(width, height), fastRendererOn ? QImage::Format_Indexed8 : QImage::Format_ARGB32){
-        if(fastRendererOn){
-            imageData = imageData.convertToFormat(QImage::Format_ARGB32);
-        }
-        imageData.fill(QColor(255,255,255,255));
-        if(fastRendererOn){
-            imageData = imageData.convertToFormat(QImage::Format_Indexed8);
-        }
-        this->fastRenderering = fastRendererOn;
+		: imageData(QSize(width, height), fastRendererOn ? QImage::Format_Indexed8 : QImage::Format_ARGB32){
+		if(fastRendererOn) {
+				imageData = imageData.convertToFormat(QImage::Format_ARGB32);
+		}
+		imageData.fill(QColor(255,255,255,255));
+		if(fastRendererOn) {
+				imageData = imageData.convertToFormat(QImage::Format_Indexed8);
+		}
+		this->fastRenderering = fastRendererOn;
 
 }
 
@@ -30,7 +30,7 @@ bool IntelliImage::loadImage(const QString &filePath){
 		// scaled Image to size of Layer
 		loadedImage = loadedImage.scaled(imageData.size(),Qt::IgnoreAspectRatio);
 
-        imageData = loadedImage.convertToFormat(fastRenderering ? QImage::Format_Indexed8 : QImage::Format_ARGB32);
+		imageData = loadedImage.convertToFormat(fastRenderering ? QImage::Format_Indexed8 : QImage::Format_ARGB32);
 		return true;
 }
 
@@ -46,115 +46,115 @@ void IntelliImage::resizeImage(QImage*image, const QSize &newSize){
 		// Draw the image
 		QPainter painter(&newImage);
 		painter.drawImage(QPoint(0, 0), *image);
-        if(fastRenderering){
-               *image = newImage.convertToFormat(QImage::Format_Indexed8);
-        }
-        else{
-               *image = newImage;
-        }
+		if(fastRenderering) {
+				*image = newImage.convertToFormat(QImage::Format_Indexed8);
+		}
+		else{
+				*image = newImage;
+		}
 }
 
 void IntelliImage::drawPixel(const QPoint &p1, const QColor& color){
-        if(fastRenderering){
-                this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
-        }
-        // Used to draw on the widget
-        QPainter* painter = new QPainter(&imageData);
+		if(fastRenderering) {
+				this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
+		}
+		// Used to draw on the widget
+		QPainter* painter = new QPainter(&imageData);
 
 		// Set the current settings for the pen
-        painter->setPen(QPen(color, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
+		painter->setPen(QPen(color, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 
 		// Draw a line from the last registered point to the current
-        painter->drawPoint(p1);
-        delete painter;
-        painter = nullptr;
+		painter->drawPoint(p1);
+		delete painter;
+		painter = nullptr;
 
-        if(fastRenderering){
-               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
-        }
+		if(fastRenderering) {
+				this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+		}
 }
 
 void IntelliImage::drawPoint(const QPoint &p1, const QColor& color, const int& penWidth){
-        if(fastRenderering){
-                 this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
-        }
-        // Used to draw on the widget
-        QPainter* painter = new QPainter(&imageData);
+		if(fastRenderering) {
+				this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
+		}
+		// Used to draw on the widget
+		QPainter* painter = new QPainter(&imageData);
 
 		// Set the current settings for the pen
-        painter->setPen(QPen(color, penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
+		painter->setPen(QPen(color, penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 		// Draw a line from the last registered point to the current
-        painter->drawPoint(p1);
-        delete painter;
+		painter->drawPoint(p1);
+		delete painter;
 
-        painter = nullptr;
-        if(fastRenderering){
-               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
-        }
+		painter = nullptr;
+		if(fastRenderering) {
+				this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+		}
 }
 
 void IntelliImage::drawLine(const QPoint &p1, const QPoint& p2, const QColor& color, const int& penWidth){
-        if(fastRenderering){
-                 this->imageData =  this->imageData.convertToFormat(QImage::Format_ARGB32);
-        }
-        // Used to draw on the widget
-        QPainter* painter = new QPainter(&imageData);
+		if(fastRenderering) {
+				this->imageData =  this->imageData.convertToFormat(QImage::Format_ARGB32);
+		}
+		// Used to draw on the widget
+		QPainter* painter = new QPainter(&imageData);
 
 		// Set the current settings for the pen
-        painter->setPen(QPen(color, penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
+		painter->setPen(QPen(color, penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 
 		// Draw a line from the last registered point to the current
-        painter->drawLine(p1, p2);
-        delete painter;
-        painter = nullptr;
+		painter->drawLine(p1, p2);
+		delete painter;
+		painter = nullptr;
 
-        if(fastRenderering){
-               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
-        }
+		if(fastRenderering) {
+				this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+		}
 }
 
 void IntelliImage::drawPlain(const QColor& color){
-        if(fastRenderering){
-               this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
-        }
-        imageData.fill(color);
-        if(fastRenderering){
-               this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
-        }
+		if(fastRenderering) {
+				this->imageData = this->imageData.convertToFormat(QImage::Format_ARGB32);
+		}
+		imageData.fill(color);
+		if(fastRenderering) {
+				this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+		}
 }
 
 QColor IntelliImage::getPixelColor(QPoint& point){
-    if(fastRenderering){
-           QImage copy = this->imageData.convertToFormat(QImage::Format_ARGB32);
-           return copy.pixelColor(point);
-    }
-    return imageData.pixelColor(point);
+		if(fastRenderering) {
+				QImage copy = this->imageData.convertToFormat(QImage::Format_ARGB32);
+				return copy.pixelColor(point);
+		}
+		return imageData.pixelColor(point);
 }
 
 QImage IntelliImage::getImageData(){
-        QImage copy = imageData;
-        if(fastRenderering){
-            copy = copy.convertToFormat(QImage::Format_ARGB32);
-        }
-        return copy;
+		QImage copy = imageData;
+		if(fastRenderering) {
+				copy = copy.convertToFormat(QImage::Format_ARGB32);
+		}
+		return copy;
 }
 
 void IntelliImage::setImageData(const QImage& newData){
-        imageData = newData;
-        if(fastRenderering){
-            this->imageData = imageData.convertToFormat(QImage::Format_Indexed8);
-        }
-        else {
-            this->imageData = imageData.convertToFormat(QImage::Format_ARGB32);
-        }
+		imageData = newData;
+		if(fastRenderering) {
+				this->imageData = imageData.convertToFormat(QImage::Format_Indexed8);
+		}
+		else {
+				this->imageData = imageData.convertToFormat(QImage::Format_ARGB32);
+		}
 }
 
 void IntelliImage::updateRendererSetting(bool fastRendererOn){
-        this->fastRenderering = fastRendererOn;
-        if(fastRenderering){
-            this->imageData = imageData.convertToFormat(QImage::Format_Indexed8);
-        }
-        else {
-            this->imageData = imageData.convertToFormat(QImage::Format_ARGB32);
-        }
+		this->fastRenderering = fastRendererOn;
+		if(fastRenderering) {
+				this->imageData = imageData.convertToFormat(QImage::Format_Indexed8);
+		}
+		else {
+				this->imageData = imageData.convertToFormat(QImage::Format_ARGB32);
+		}
 }
diff --git a/src/Image/IntelliRasterImage.cpp b/src/Image/IntelliRasterImage.cpp
index 6ebf497..3106e36 100644
--- a/src/Image/IntelliRasterImage.cpp
+++ b/src/Image/IntelliRasterImage.cpp
@@ -4,9 +4,9 @@
 #include <QDebug>
 
 IntelliRasterImage::IntelliRasterImage(int width, int height, bool fastRendererOn)
-        : IntelliImage(width, height, fastRendererOn){
-        TypeOfImage = IntelliImage::ImageType::RASTERIMAGE;
-        this->fastRenderering = fastRendererOn;
+		: IntelliImage(width, height, fastRendererOn){
+		TypeOfImage = IntelliImage::ImageType::RASTERIMAGE;
+		this->fastRenderering = fastRendererOn;
 }
 
 IntelliRasterImage::~IntelliRasterImage(){
@@ -30,9 +30,9 @@ QImage IntelliRasterImage::getDisplayable(int alpha){
 
 QImage IntelliRasterImage::getDisplayable(const QSize& displaySize, int alpha){
 		QImage copy = imageData;
-        if(fastRenderering){
-            copy = copy.convertToFormat(QImage::Format_ARGB32);
-        }
+		if(fastRenderering) {
+				copy = copy.convertToFormat(QImage::Format_ARGB32);
+		}
 		for(int y = 0; y<copy.height(); y++) {
 				for(int x = 0; x<copy.width(); x++) {
 						QColor clr = copy.pixelColor(x,y);
@@ -40,9 +40,9 @@ QImage IntelliRasterImage::getDisplayable(const QSize& displaySize, int alpha){
 						copy.setPixelColor(x,y, clr);
 				}
 		}
-        if(fastRenderering){
-            copy = copy.convertToFormat(QImage::Format_Indexed8);
-        }
+		if(fastRenderering) {
+				copy = copy.convertToFormat(QImage::Format_Indexed8);
+		}
 		return copy.scaled(displaySize,Qt::IgnoreAspectRatio);
 }
 
diff --git a/src/Image/IntelliShapedImage.cpp b/src/Image/IntelliShapedImage.cpp
index 8131d52..b8a7bec 100644
--- a/src/Image/IntelliShapedImage.cpp
+++ b/src/Image/IntelliShapedImage.cpp
@@ -5,9 +5,9 @@
 #include <QDebug>
 
 IntelliShapedImage::IntelliShapedImage(int width, int height, bool fastRendererOn)
-        : IntelliRasterImage(width, height, fastRendererOn){
-        TypeOfImage = IntelliImage::ImageType::SHAPEDIMAGE;
-        this->fastRenderering = fastRendererOn;
+		: IntelliRasterImage(width, height, fastRendererOn){
+		TypeOfImage = IntelliImage::ImageType::SHAPEDIMAGE;
+		this->fastRenderering = fastRendererOn;
 }
 
 IntelliShapedImage::~IntelliShapedImage(){
@@ -27,9 +27,12 @@ IntelliImage* IntelliShapedImage::getDeepCopy(){
 }
 
 void IntelliShapedImage::calculateVisiblity(){
-        if(fastRenderering){
-            this->imageData = imageData.convertToFormat(QImage::Format_ARGB32);
-        }
+		if(polygonData.size()<2) {
+				return;
+		}
+		if(fastRenderering) {
+				this->imageData = imageData.convertToFormat(QImage::Format_ARGB32);
+		}
 
 		if(polygonData.size()<=2) {
 				QColor clr;
@@ -40,9 +43,9 @@ void IntelliShapedImage::calculateVisiblity(){
 								imageData.setPixelColor(x,y,clr);
 						}
 				}
-                if(fastRenderering){
-                     this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
-                }
+				if(fastRenderering) {
+						this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+				}
 				return;
 		}
 		QColor clr;
@@ -59,16 +62,16 @@ void IntelliShapedImage::calculateVisiblity(){
 						imageData.setPixelColor(x,y,clr);
 				}
 		}
-        if(fastRenderering){
-             this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
-        }
+		if(fastRenderering) {
+				this->imageData = this->imageData.convertToFormat(QImage::Format_Indexed8);
+		}
 }
 
 QImage IntelliShapedImage::getDisplayable(const QSize& displaySize, int alpha){
 		QImage copy = imageData;
-        if(fastRenderering){
-             copy = copy.convertToFormat(QImage::Format_ARGB32);
-        }
+		if(fastRenderering) {
+				copy = copy.convertToFormat(QImage::Format_ARGB32);
+		}
 		for(int y = 0; y<copy.height(); y++) {
 				for(int x = 0; x<copy.width(); x++) {
 						QColor clr = copy.pixelColor(x,y);
@@ -76,9 +79,9 @@ QImage IntelliShapedImage::getDisplayable(const QSize& displaySize, int alpha){
 						copy.setPixelColor(x,y, clr);
 				}
 		}
-        if(fastRenderering){
-             copy = copy.convertToFormat(QImage::Format_Indexed8);
-        }
+		if(fastRenderering) {
+				copy = copy.convertToFormat(QImage::Format_Indexed8);
+		}
 		return copy.scaled(displaySize,Qt::IgnoreAspectRatio);
 }
 
@@ -91,6 +94,19 @@ void IntelliShapedImage::setPolygon(const std::vector<QPoint>& polygonData){
 						this->polygonData.push_back(QPoint(element.x(), element.y()));
 				}
 				triangles = IntelliTriangulation::calculateTriangles(polygonData);
+				if(fastRenderering) {
+						imageData = imageData.convertToFormat(QImage::Format_ARGB32);
+				}
+				for(int y = 0; y<imageData.height(); y++) {
+						for(int x = 0; x<imageData.width(); x++) {
+								QColor clr = imageData.pixelColor(x,y);
+								clr.setAlpha(255);
+								imageData.setPixelColor(x,y,clr);
+						}
+				}
+				if(fastRenderering) {
+						imageData = imageData.convertToFormat(QImage::Format_Indexed8);
+				}
 		}
 		calculateVisiblity();
 		return;
diff --git a/src/IntelliHelper/IntelliRenderSettings.cpp b/src/IntelliHelper/IntelliRenderSettings.cpp
index ea36289..c1f6b19 100644
--- a/src/IntelliHelper/IntelliRenderSettings.cpp
+++ b/src/IntelliHelper/IntelliRenderSettings.cpp
@@ -6,9 +6,9 @@ IntelliRenderSettings::IntelliRenderSettings()
 }
 
 void IntelliRenderSettings::setFastRendering(bool Updatedsetting){
-        this->fastRenderering = Updatedsetting;
+		this->fastRenderering = Updatedsetting;
 }
 
 bool IntelliRenderSettings::isFastRenderering(){
-        return fastRenderering;
+		return fastRenderering;
 }
diff --git a/src/Layer/PaintingArea.cpp b/src/Layer/PaintingArea.cpp
index 224cf80..f1a1cc6 100644
--- a/src/Layer/PaintingArea.cpp
+++ b/src/Layer/PaintingArea.cpp
@@ -18,10 +18,13 @@
 #include "Tool/IntelliToolFloodFill.h"
 #include "Tool/IntelliToolPolygon.h"
 
+
 PaintingArea::PaintingArea(int maxWidth, int maxHeight, QWidget*parent)
 		: QWidget(parent){
 		this->Tool = nullptr;
 		this->setLayerDimensions(maxWidth, maxHeight);
+
+		activeLayer=-1;
 }
 
 PaintingArea::~PaintingArea(){
@@ -29,12 +32,12 @@ PaintingArea::~PaintingArea(){
 }
 
 void PaintingArea::setRenderSettings(bool isFastRenderingOn){
-        if(isFastRenderingOn != renderSettings.isFastRenderering()){
-            renderSettings.setFastRendering(isFastRenderingOn);
-            for(auto& layer : layerBundle){
-                layer.image->updateRendererSetting(isFastRenderingOn);
-            }
-        }
+		if(isFastRenderingOn != renderSettings.isFastRenderering()) {
+				renderSettings.setFastRendering(isFastRenderingOn);
+				for(auto& layer : layerBundle) {
+						layer.image->updateRendererSetting(isFastRenderingOn);
+				}
+		}
 }
 
 void PaintingArea::setLayerDimensions(int maxWidth, int maxHeight){
@@ -50,14 +53,15 @@ void PaintingArea::setLayerDimensions(int maxWidth, int maxHeight){
 
 int PaintingArea::addLayer(int width, int height, int widthOffset, int heightOffset, IntelliImage::ImageType type){
 		LayerObject newLayer;
+		updateTools();
 		newLayer.width = width;
 		newLayer.height = height;
 		newLayer.widthOffset = widthOffset;
 		newLayer.heightOffset = heightOffset;
-        if(type==IntelliImage::ImageType::RASTERIMAGE) {
-                newLayer.image = new IntelliRasterImage(width,height,renderSettings.isFastRenderering());
-        }else if(type==IntelliImage::ImageType::SHAPEDIMAGE) {
-                newLayer.image = new IntelliShapedImage(width, height, renderSettings.isFastRenderering());
+		if(type==IntelliImage::ImageType::RASTERIMAGE) {
+				newLayer.image = new IntelliRasterImage(width,height,renderSettings.isFastRenderering());
+		}else if(type==IntelliImage::ImageType::SHAPEDIMAGE) {
+				newLayer.image = new IntelliShapedImage(width, height, renderSettings.isFastRenderering());
 		}
 		newLayer.alpha = 255;
 		this->layerBundle.push_back(newLayer);
@@ -66,15 +70,18 @@ int PaintingArea::addLayer(int width, int height, int widthOffset, int heightOff
 }
 
 
-void PaintingArea::deleteLayer(int idx){
-        if(idx < static_cast<int>(layerBundle.size())&&idx>=0) {
+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) {
+				if(activeLayer>=idx) {
 						activeLayer--;
 				}
-                if(activeLayer < 0 && layerBundle.size()){
-                    activeLayer=0;
-                }
+				if(activeLayer < 0 && layerBundle.size()) {
+						activeLayer=0;
+				}
 		}
 }
 
@@ -86,6 +93,7 @@ void PaintingArea::slotDeleteActiveLayer(){
 }
 
 void PaintingArea::setLayerActive(int idx){
+		updateTools();
 		if(idx>=0&&idx<static_cast<int>(layerBundle.size())) {
 				this->activeLayer=idx;
 		}
@@ -93,9 +101,18 @@ void PaintingArea::setLayerActive(int 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;
-                }
+				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()==IntelliImage::ImageType::SHAPEDIMAGE) {
+						delete this->Tool;
+						this->Tool = new IntelliToolPolygon(this,&colorPicker,&Toolsettings, true);
+						isSettingPolygon = true;
+				}
 		}
 }
 
@@ -135,42 +152,14 @@ bool PaintingArea::save(const QString &filePath, const char*fileFormat){
 		}
 }
 
-// Color the image area with white
-void PaintingArea::floodFill(int r, int g, int b, int a){
-		if(this->activeLayer==-1) {
-				return;
-		}
-        if(r >255 || g>255|| b>255 || a>255){
-            return;
-        }
-        if(r < 0 || g < 0|| b < 0 || a < 0){
-            return;
-        }
-		IntelliImage* active = layerBundle[static_cast<size_t>(activeLayer)].image;
-		active->drawPlain(QColor(r, g, b, a));
-		update();
-}
-
 void PaintingArea::movePositionActive(int x, int y){
-		if(Tool!=nullptr) {
-				if(Tool->getIsDrawing()) {
-						IntelliTool* temp = copyActiveTool();
-						delete this->Tool;
-						this->Tool = temp;
-				}
-		}
+		updateTools();
 		layerBundle[static_cast<size_t>(activeLayer)].widthOffset += x;
 		layerBundle[static_cast<size_t>(activeLayer)].heightOffset += y;
 }
 
 void PaintingArea::moveActiveLayer(int idx){
-		if(Tool != nullptr) {
-				if(Tool->getIsDrawing()) {
-						IntelliTool* temp = copyActiveTool();
-						delete this->Tool;
-						this->Tool = temp;
-				}
-		}
+		updateTools();
 		if(idx==1) {
 				this->selectLayerUp();
 		}else if(idx==-1) {
@@ -179,13 +168,7 @@ void PaintingArea::moveActiveLayer(int idx){
 }
 
 void PaintingArea::slotActivateLayer(int a){
-		if(Tool != nullptr) {
-				if(Tool->getIsDrawing()) {
-						IntelliTool* temp = copyActiveTool();
-						delete this->Tool;
-						this->Tool = temp;
-				}
-		}
+		updateTools();
 		if(a>=0 && a < static_cast<int>(layerBundle.size())) {
 				this->setLayerActive(a);
 		}
@@ -259,9 +242,9 @@ std::vector<QPoint> PaintingArea::getPolygonDataOfRealLayer(){
 // 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(this->activeLayer < 0) {
+				return;
+		}
 		if(Tool == nullptr)
 				return;
 		int x = event->x()-layerBundle[static_cast<unsigned long long>(activeLayer)].widthOffset;
@@ -278,9 +261,9 @@ void PaintingArea::mousePressEvent(QMouseEvent*event){
 // 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(this->activeLayer < 0) {
+				return;
+		}
 		if(Tool == nullptr)
 				return;
 		int x = event->x()-layerBundle[static_cast<unsigned long long>(activeLayer)].widthOffset;
@@ -291,9 +274,9 @@ void PaintingArea::mouseMoveEvent(QMouseEvent*event){
 
 // If the button is released we set variables to stop drawing
 void PaintingArea::mouseReleaseEvent(QMouseEvent*event){
-        if(this->activeLayer < 0)
-                return;
-        if(Tool == nullptr)
+		if(this->activeLayer < 0)
+				return;
+		if(Tool == nullptr)
 				return;
 		int x = event->x()-layerBundle[static_cast<unsigned long long>(activeLayer)].widthOffset;
 		int y = event->y()-layerBundle[static_cast<unsigned long long>(activeLayer)].heightOffset;
@@ -306,9 +289,9 @@ void PaintingArea::mouseReleaseEvent(QMouseEvent*event){
 }
 
 void PaintingArea::wheelEvent(QWheelEvent*event){
-        if(this->activeLayer < 0)
-                return;
-        if(this->Tool != nullptr) {
+		if(this->activeLayer < 0)
+				return;
+		if(this->Tool != nullptr) {
 				QPoint numDegrees = event->angleDelta() / 8;
 				if(!numDegrees.isNull()) {
 						QPoint numSteps = numDegrees / 15;
@@ -329,7 +312,7 @@ void PaintingArea::paintEvent(QPaintEvent*event){
 		update();
 }
 
-// Resize the image to slightly larger then the main window
+//TODOJ Resize the image to slightly larger then the main window
 // to cut down on the need to resize the image
 void PaintingArea::resizeEvent(QResizeEvent*event){
 		//TODO wait till tool works
@@ -341,6 +324,7 @@ void PaintingArea::resizeLayer(QImage*image_res, const QSize &newSize){
 }
 
 void PaintingArea::selectLayerUp(){
+		updateTools();
 		if(activeLayer!=-1 && static_cast<unsigned long long>(activeLayer)<layerBundle.size()-1) {
 				std::swap(layerBundle[static_cast<unsigned long long>(activeLayer)], layerBundle[static_cast<unsigned long long>(activeLayer+1)]);
 				activeLayer++;
@@ -348,6 +332,7 @@ void PaintingArea::selectLayerUp(){
 }
 
 void PaintingArea::selectLayerDown(){
+		updateTools();
 		if(activeLayer!=-1 && activeLayer>0) {
 				std::swap(layerBundle[static_cast<unsigned long long>(activeLayer)], layerBundle[static_cast<unsigned long long>(activeLayer-1)]);
 				activeLayer--;
@@ -399,9 +384,9 @@ bool PaintingArea::createTempTopLayer(int idx){
 				newLayer.widthOffset = layerBundle[static_cast<unsigned long long>(idx)].widthOffset;
 				newLayer.image = layerBundle[static_cast<unsigned long long>(idx)].image->getDeepCopy();
 				layerBundle.insert(layerBundle.begin()+idx+1,newLayer);
-                return true;
+				return true;
 		}
-        return false;
+		return false;
 }
 
 IntelliTool* PaintingArea::copyActiveTool(){
@@ -422,8 +407,38 @@ int PaintingArea::getNumberOfActiveLayer(){
 }
 
 IntelliImage* PaintingArea::getImageOfActiveLayer(){
-        if(activeLayer<0){
-            return nullptr;
-        }
-		return layerBundle[activeLayer].image;
+		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;
+}
+
+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;
+				}
+		}
 }
diff --git a/src/Layer/PaintingArea.h b/src/Layer/PaintingArea.h
index 72c6b59..48c1c7d 100644
--- a/src/Layer/PaintingArea.h
+++ b/src/Layer/PaintingArea.h
@@ -39,7 +39,7 @@ struct LayerObject {
  */
 class PaintingArea : public QWidget
 {
-    friend UnitTest;
+friend UnitTest;
 // Declares our class as a QObject which is the base class
 // for all Qt objects
 // QObjects handle events
@@ -47,142 +47,146 @@ Q_OBJECT
 friend IntelliTool;
 friend IntelliPhotoGui;
 public:
-    /*!
-     * \brief PaintingArea is the constructor of the PaintingArea class, which initiates the working environment
-     * \param maxWidth      - The maximum amount of pixles that are inside painting area from left to right (default=600px)
-     * \param maxHeight     - The maximum amount of pixles that are inside painting area from top to bottom (default=600px)
-     * \param parent        - The parent window of the main window (default=nullptr)
-     */
-    PaintingArea(int maxWidth=600, int maxHeight=600, QWidget *parent = nullptr);
+/*!
+ * \brief PaintingArea is the constructor of the PaintingArea class, which initiates the working environment
+ * \param maxWidth      - The maximum amount of pixles that are inside painting area from left to right (default=600px)
+ * \param maxHeight     - The maximum amount of pixles that are inside painting area from top to bottom (default=600px)
+ * \param parent        - The parent window of the main window (default=nullptr)
+ */
+PaintingArea(int maxWidth=600, int maxHeight=600, QWidget*parent = nullptr);
 
-    /*!
-     * \brief This deconstructor is used to clear up the memory and remove the currently active window
-     */
-    ~PaintingArea() override;
+/*!
+ * \brief This deconstructor is used to clear up the memory and remove the currently active window
+ */
+~PaintingArea() override;
 
-    // Handles all events
+// Handles all events
 
-    /*!
-     * \brief setRenderSettings updates all Images to the new Rendersetting.
-     * \param isFastRenderingOn is the new given flag for the FastRenderer.
-     */
-    void setRenderSettings(bool isFastRenderingOn);
+/*!
+ * \brief setRenderSettings updates all Images to the new Rendersetting.
+ * \param isFastRenderingOn is the new given flag for the FastRenderer.
+ */
+void setRenderSettings(bool isFastRenderingOn);
 
-    /*!
-     * \brief The open method is used for loading a picture into the current layer
-     * \param fileName  - Path and filename which are used to determine where the to-be-opened file is stored
-     * \return Returns a boolean variable whether the file was successfully opened or not
-     */
-    bool open(const QString &filePath);
-    /*!
-     * \brief The save method is used for exporting the current project as one picture
-     * \param fileName
-     * \param fileFormat
-     * \return Returns a boolean variable, true if the file was saved successfully, false if not
-     */
-    bool save(const QString &filePath, const char *fileFormat);
+/*!
+ * \brief The open method is used for loading a picture into the current layer
+ * \param fileName  - Path and filename which are used to determine where the to-be-opened file is stored
+ * \return Returns a boolean variable whether the file was successfully opened or not
+ */
+bool open(const QString &filePath);
+/*!
+ * \brief The save method is used for exporting the current project as one picture
+ * \param fileName
+ * \param fileFormat
+ * \return Returns a boolean variable, true if the file was saved successfully, false if not
+ */
+bool save(const QString &filePath, const char*fileFormat);
 
-    /*!
-     * \brief The addLayer adds a layer to the current project/ painting area
-     * \param width         - Width of the layer in pixles
-     * \param height        - Height of the layer in pixles
-     * \param widthOffset   - Offset of the layer measured to the left border of the painting area in pixles
-     * \param heightOffset  - Offset of the layer measured to the top border of the painting area in pixles
-     * \param type          - Defining the ImageType of the new layer
-     * \return  Returns the number of layers in the project
-     */
-    int addLayer(int width, int height, int widthOffset=0, int heightOffset=0, IntelliImage::ImageType type = IntelliImage::ImageType::RASTERIMAGE);
-    /*!
-     * \brief The addLayerAt adds a layer to the current project/ painting area at a specific position in the layer stack
-     * \param idx           - Index of the position the new layer should be added
-     * \param width         - Width of the layer in pixles
-     * \param height        - Height of the layer in pixles
-     * \param widthOffset   - Offset of the layer measured to the left border of the painting area in pixles
-     * \param heightOffset  - Offset of the layer measured to the top border of the painting area in pixles
-     * \param type          - Defining the ImageType of the new layer
-     * \return  Returns the id of the layer position
-     */
-    int addLayerAt(int idx, int width, int height, int widthOffset=0, int heightOffset=0, IntelliImage::ImageType type = IntelliImage::ImageType::RASTERIMAGE);
-    /*!
-     * \brief The deleteLayer method removes a layer at a given idx
-     * \param idx - The index of the layer to be removed
-     */
-    void deleteLayer(int idx);
-    /*!
-     * \brief The setLayerToActive method marks a specific layer as active
-     * \param idx - The index of the layer to be active
-     */
-    void setLayerActive(int idx);
-    /*!
-     * \brief The setAlphaOfLayer method sets the alpha value of a specific layer
-     * \param idx     - The index of the layer where the change should be applied
-     * \param alpha     - New alpha value of the layer
-     */
-    void setLayerAlpha(int idx, int alpha);
-    /*!
-     * \brief The floodFill method fills a the active layer with a given color
-     * \param r     - Red value of the color the layer should be filled with
-     * \param g     - Green value of the color the layer should be filled with
-     * \param b     - Blue value of the color the layer should be filled with
-     * \param a     - Alpha value of the color the layer should be filled with
-     */
-    void floodFill(int r, int g, int b, int a);
-    /*!
-     * \brief The movePositionActive method moves the active layer to certain position
-     * \param x     - The x value the new center of the layer should be at
-     * \param y     - The y value the new center of the layer should be at
-     */
-    void movePositionActive(int x, int y);
-    /*!
-     * \brief The moveActiveLayer moves the active layer to a specific position in the layer stack
-     * \param idx   - The direction the layer should move
-     */
-    void moveActiveLayer(int idx);
+/*!
+ * \brief The addLayer adds a layer to the current project/ painting area
+ * \param width         - Width of the layer in pixles
+ * \param height        - Height of the layer in pixles
+ * \param widthOffset   - Offset of the layer measured to the left border of the painting area in pixles
+ * \param heightOffset  - Offset of the layer measured to the top border of the painting area in pixles
+ * \param type          - Defining the ImageType of the new layer
+ * \return  Returns the number of layers in the project
+ */
+int addLayer(int width, int height, int widthOffset=0, int heightOffset=0, IntelliImage::ImageType type = IntelliImage::ImageType::RASTERIMAGE);
+/*!
+ * \brief The addLayerAt adds a layer to the current project/ painting area at a specific position in the layer stack
+ * \param idx           - Index of the position the new layer should be added
+ * \param width         - Width of the layer in pixles
+ * \param height        - Height of the layer in pixles
+ * \param widthOffset   - Offset of the layer measured to the left border of the painting area in pixles
+ * \param heightOffset  - Offset of the layer measured to the top border of the painting area in pixles
+ * \param type          - Defining the ImageType of the new layer
+ * \return  Returns the id of the layer position
+ */
+int addLayerAt(int idx, int width, int height, int widthOffset=0, int heightOffset=0, IntelliImage::ImageType type = IntelliImage::ImageType::RASTERIMAGE);
+/*!
+ * \brief The deleteLayer method removes a layer at a given idx
+ * \param idx - The index of the layer to be removed
+ * \param isTool - Is the flag for when a tool uses this function.
+ */
+void deleteLayer(int idx, bool isTool = false);
+/*!
+ * \brief The setLayerToActive method marks a specific layer as active
+ * \param idx - The index of the layer to be active
+ */
+void setLayerActive(int idx);
+/*!
+ * \brief The setAlphaOfLayer method sets the alpha value of a specific layer
+ * \param idx     - The index of the layer where the change should be applied
+ * \param alpha     - New alpha value of the layer
+ */
+void setLayerAlpha(int idx, int alpha);
+/*!
+ * \brief setPolygon is used for setting polygondata, it only works on RASTER images
+ * \param idx - represents the number of the layer with should be transformed
+ */
+void setPolygon(int idx);
+/*!
+ * \brief The movePositionActive method moves the active layer to certain position
+ * \param x     - The x value the new center of the layer should be at
+ * \param y     - The y value the new center of the layer should be at
+ */
+void movePositionActive(int x, int y);
+/*!
+ * \brief The moveActiveLayer moves the active layer to a specific position in the layer stack
+ * \param idx   - The index of the new position the layer should be in
+ */
+void moveActiveLayer(int idx);
 
-    //change properties of colorPicker
-    /*!
-     * \brief The colorPickerSetFirstColor calls the QTColorPicker to determine the primary drawing color
-     */
-    void colorPickerSetFirstColor();
-    /*!
-     * \brief The colorPickerSetSecondColor calls the QTColorPicker to determine the secondary drawing color
-     */
-    void colorPickerSetSecondColor();
-    /*!
-     * \brief The colorPickerSwitchColor swaps the primary color with the secondary drawing color
-     */
-    void colorPickerSwapColors();
+//change properties of colorPicker
+/*!
+ * \brief The colorPickerSetFirstColor calls the QTColorPicker to determine the primary drawing color
+ */
+void colorPickerSetFirstColor();
+/*!
+ * \brief The colorPickerSetSecondColor calls the QTColorPicker to determine the secondary drawing color
+ */
+void colorPickerSetSecondColor();
+/*!
+ * \brief The colorPickerSwitchColor swaps the primary color with the secondary drawing color
+ */
+void colorPickerSwapColors();
 
-    // Create tools
-    void createPenTool();
-    void createPlainTool();
-    void createLineTool();
-    void createRectangleTool();
-    void createCircleTool();
-    void createPolygonTool();
-    void createFloodFillTool();
+// Create tools
+void createPenTool();
+void createPlainTool();
+void createLineTool();
+void createRectangleTool();
+void createCircleTool();
+void createPolygonTool();
+void createFloodFillTool();
 
-    /*!
-     * \brief The getWidthOfActive gets the horizontal dimensions of the active layer
-     * \return Returns the horizontal pixle count of the active layer
-     */
-    int getWidthOfActive();
-    /*!
-     * \brief The getHeightOfActive gets the vertical dimensions of the active layer
-     * \return Returns the vertical pixle count of the active layer
-     */
-    int getHeightOfActive();
+/*!
+ * \brief The getWidthOfActive gets the horizontal dimensions of the active layer
+ * \return Returns the horizontal pixle count of the active layer
+ */
+int getWidthOfActive();
+/*!
+ * \brief The getHeightOfActive gets the vertical dimensions of the active layer
+ * \return Returns the vertical pixle count of the active layer
+ */
+int getHeightOfActive();
 
-    IntelliImage::ImageType getTypeOfImageRealLayer();
+IntelliImage::ImageType getTypeOfImageRealLayer();
 
-    std::vector<QPoint> getPolygonDataOfRealLayer();
+std::vector<QPoint> getPolygonDataOfRealLayer();
 
-    int getNumberOfActiveLayer();
+int getNumberOfActiveLayer();
 
-    IntelliImage* getImageOfActiveLayer();
+IntelliImage* getImageOfActiveLayer();
 
-    IntelliToolsettings Toolsettings;
-    IntelliColorPicker colorPicker;
+/*!
+ * \brief getImageDataOfActiveLayer used to get the currents active imageData (if there isn't any active layer it return a 10*10 white picture)
+ * \return return the image as an rgba32bit qImage
+ */
+QImage getImageDataOfActiveLayer();
+
+IntelliToolsettings Toolsettings;
+IntelliColorPicker colorPicker;
 
 public slots:
 // Events to handle
@@ -219,6 +223,8 @@ QImage* Canvas;
 int maxWidth;
 int maxHeight;
 
+bool isSettingPolygon = false;
+
 IntelliRenderSettings renderSettings;
 IntelliTool* Tool;
 IntelliPhotoGui* DummyGui;
@@ -230,8 +236,11 @@ void drawLayers(bool forSaving=false);
 
 void resizeLayer(QImage*image_res, const QSize &newSize);
 
-    // Helper for Tool
-    bool createTempTopLayer(int idx);
+// Helper for Tool
+bool createTempTopLayer(int idx);
+
+//this function is needed to avoid errors in inputhandeling if a layer has changed
+void updateTools();
 };
 
 #endif
diff --git a/src/Tool/IntelliTool.cpp b/src/Tool/IntelliTool.cpp
index 7f5b54f..be36ae1 100644
--- a/src/Tool/IntelliTool.cpp
+++ b/src/Tool/IntelliTool.cpp
@@ -24,10 +24,10 @@ void IntelliTool::onMouseRightReleased(int x, int y){
 }
 
 void IntelliTool::onMouseLeftPressed(int x, int y){
-        this->isDrawing=this->createToolLayer();
-        if(isDrawing){
-            Canvas->image->calculateVisiblity();
-        }
+		this->isDrawing=this->createToolLayer();
+		if(isDrawing) {
+				Canvas->image->calculateVisiblity();
+		}
 }
 
 void IntelliTool::onMouseLeftReleased(int x, int y){
@@ -36,6 +36,7 @@ void IntelliTool::onMouseLeftReleased(int x, int y){
 				this->mergeToolLayer();
 				this->deleteToolLayer();
 				activeLayer->image->calculateVisiblity();
+
 		}
 }
 
@@ -49,22 +50,22 @@ void IntelliTool::onWheelScrolled(int value){
 }
 
 bool IntelliTool::createToolLayer(){
-        if(Area->createTempTopLayer(Area->activeLayer)){
-            this->activeLayer=&Area->layerBundle[static_cast<unsigned long long>(Area->activeLayer)];
-            this->Canvas=&Area->layerBundle[static_cast<unsigned long long>(Area->activeLayer+1)];
-            return true;
-        }
-        return false;
+		if(Area->createTempTopLayer(Area->activeLayer)) {
+				this->activeLayer=&Area->layerBundle[static_cast<unsigned long long>(Area->activeLayer)];
+				this->Canvas=&Area->layerBundle[static_cast<unsigned long long>(Area->activeLayer+1)];
+				return true;
+		}
+		return false;
 }
 
 void IntelliTool::mergeToolLayer(){
 		QColor clr_0;
 		QColor clr_1;
-        QImage updatedImage = activeLayer->image->getImageData();
+		QImage updatedImage = activeLayer->image->getImageData();
 
 		for(int y=0; y<activeLayer->height; y++) {
-                for(int x=0; x<activeLayer->width; x++) {
-                        clr_0=updatedImage.pixelColor(x,y);
+				for(int x=0; x<activeLayer->width; x++) {
+						clr_0=updatedImage.pixelColor(x,y);
 						clr_1=Canvas->image->imageData.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);
@@ -76,15 +77,18 @@ void IntelliTool::mergeToolLayer(){
 						clr_0.setBlue(b);
 						clr_0.setAlpha(a);
 
-                        updatedImage.setPixelColor(x, y, clr_0);
+						updatedImage.setPixelColor(x, y, clr_0);
 				}
 		}
-        activeLayer->image->setImageData(updatedImage);
-        Area->DummyGui->UpdateGui();
+		activeLayer->image->setImageData(updatedImage);
+		if(Canvas->image->getPolygonData().size() > 0) {
+				activeLayer->image->setPolygon(Canvas->image->getPolygonData());
+		}
+		Area->DummyGui->UpdateGui();
 }
 
 void IntelliTool::deleteToolLayer(){
-		Area->deleteLayer(Area->activeLayer+1);
+		Area->deleteLayer(Area->activeLayer+1, true);
 		this->Canvas=nullptr;
 }
 
diff --git a/src/Tool/IntelliToolCircle.cpp b/src/Tool/IntelliToolCircle.cpp
index cde5da6..d2a09d1 100644
--- a/src/Tool/IntelliToolCircle.cpp
+++ b/src/Tool/IntelliToolCircle.cpp
@@ -26,7 +26,7 @@ void IntelliToolCircle::drawCircle(int radius){
 		}
 
 		//TODO implement circle drawing algorithm bresenham
-        radius = static_cast<int>(radius +(Toolsettings->getLineWidth()/2.));
+		radius = static_cast<int>(radius +(Toolsettings->getLineWidth()/2.));
 		yMin = (centerPoint.y()-radius);
 		yMax = (centerPoint.y()+radius);
 		for(int i=yMin; i<=yMax; i++) {
@@ -56,12 +56,12 @@ void IntelliToolCircle::onMouseRightReleased(int x, int y){
 
 void IntelliToolCircle::onMouseLeftPressed(int x, int y){
 		IntelliTool::onMouseLeftPressed(x,y);
-        if(this->isDrawing){
-            this->centerPoint=QPoint(x,y);
-            int radius = 1;
-            drawCircle(radius);
-            Canvas->image->calculateVisiblity();
-        }
+		if(this->isDrawing) {
+				this->centerPoint=QPoint(x,y);
+				int radius = 1;
+				drawCircle(radius);
+				Canvas->image->calculateVisiblity();
+		}
 }
 
 void IntelliToolCircle::onMouseLeftReleased(int x, int y){
diff --git a/src/Tool/IntelliToolLine.cpp b/src/Tool/IntelliToolLine.cpp
index 45194de..120d3a2 100644
--- a/src/Tool/IntelliToolLine.cpp
+++ b/src/Tool/IntelliToolLine.cpp
@@ -49,7 +49,7 @@ void IntelliToolLine::onMouseMoved(int x, int y){
 						QPoint p2 =lineStartingPoint.x() < next.x() ? next : lineStartingPoint;
 						int m = static_cast<int>(static_cast<float>(p2.y()-p1.y())/static_cast<float>(p2.x()-p1.x())+0.5f);
 						int c = lineStartingPoint.y()-lineStartingPoint.x()*m;
-                        //TODO implement dotted algorithm
+						//TODO implement dotted algorithm
 						break;
 				}
 		}
diff --git a/src/Tool/IntelliToolPolygon.cpp b/src/Tool/IntelliToolPolygon.cpp
index 57eb7c1..8219c7d 100644
--- a/src/Tool/IntelliToolPolygon.cpp
+++ b/src/Tool/IntelliToolPolygon.cpp
@@ -4,60 +4,75 @@
 #include <QInputDialog>
 #include <QDebug>
 
-IntelliToolPolygon::IntelliToolPolygon(PaintingArea* Area, IntelliColorPicker* colorPicker, IntelliToolsettings* Toolsettings)
+IntelliToolPolygon::IntelliToolPolygon(PaintingArea* Area, IntelliColorPicker* colorPicker, IntelliToolsettings* Toolsettings, bool isSettingPolygon)
 		: IntelliTool(Area, colorPicker, Toolsettings){
 		isPointNearStart = false;
-        drawingOfPolygon = false;
+		drawingOfPolygon = false;
 		isInside = false;
+		this->isSettingPolygon = isSettingPolygon;
 		this->ActiveType = Tooltype::POLYGON;
 }
 
 IntelliToolPolygon::~IntelliToolPolygon(){
-        if(drawingOfPolygon) {
+		if(drawingOfPolygon) {
 				IntelliTool::onMouseRightPressed(0,0);
 		}
 }
 
 void IntelliToolPolygon::onMouseLeftPressed(int x, int y){
-        if(!drawingOfPolygon && Area->getTypeOfImageRealLayer() == IntelliImage::ImageType::SHAPEDIMAGE && x >= 0 && y >= 0 && x<Area->getWidthOfActive() && y<Area->getHeightOfActive()) {
-				std::vector<Triangle> Triangles = IntelliTriangulation::calculateTriangles(Area->getPolygonDataOfRealLayer());
-				QPoint Point(x,y);
-				isInside = IntelliTriangulation::isInPolygon(Triangles,Point);
+		if(!isDrawing && Area->getTypeOfImageRealLayer() == IntelliImage::ImageType::SHAPEDIMAGE && x > 0 && y > 0 && x<Area->getWidthOfActive() && y<Area->getHeightOfActive()) {
+				if(Area->getPolygonDataOfRealLayer().size()>2) {
+						std::vector<Triangle> Triangles = IntelliTriangulation::calculateTriangles(Area->getPolygonDataOfRealLayer());
+						QPoint Point(x,y);
+						isInside = IntelliTriangulation::isInPolygon(Triangles,Point);
+				}
+				else{
+						isInside = true;
+				}
+				if(isSettingPolygon) {
+						isInside = true;
+				}
 		}
-        else if(!drawingOfPolygon && Area->getTypeOfImageRealLayer() == IntelliImage::ImageType::RASTERIMAGE && x >= 0 && y >= 0 && x<Area->getWidthOfActive() && y<Area->getHeightOfActive()) {
+		else if(!drawingOfPolygon && Area->getTypeOfImageRealLayer() == IntelliImage::ImageType::RASTERIMAGE && x >= 0 && y >= 0 && x<Area->getWidthOfActive() && y<Area->getHeightOfActive()) {
 				isInside = true;
 		}
 
-        if(isInside && !drawingOfPolygon) {
+		if(isInside && !drawingOfPolygon) {
 				IntelliTool::onMouseLeftPressed(x,y);
 				QPoint drawingPoint = QPoint(x,y);
 
-                drawingOfPolygon = true;
+				drawingOfPolygon = true;
 				QPointList.push_back(drawingPoint);
 
 				this->Canvas->image->drawPoint(QPointList.back(), colorPicker->getFirstColor(), Toolsettings->getLineWidth());
-				this->Canvas->image->calculateVisiblity();
+				if(!isSettingPolygon) {
+						this->Canvas->image->calculateVisiblity();
+				}
 		}
-        else if(drawingOfPolygon && isNearStart(x,y,QPointList.front())) {
+		else if(drawingOfPolygon && isNearStart(x,y,QPointList.front())) {
 				if(QPointList.size() > 2) {
 						isPointNearStart = true;
 						this->Canvas->image->drawLine(QPointList.back(), QPointList.front(), colorPicker->getFirstColor(), Toolsettings->getLineWidth());
-						this->Canvas->image->calculateVisiblity();
+						if(!isSettingPolygon) {
+								this->Canvas->image->calculateVisiblity();
+						}
 				}
 				else{
 						isInside = false;
-                        drawingOfPolygon = false;
+						drawingOfPolygon = false;
 						QPointList.clear();
 						IntelliTool::onMouseRightPressed(x,y);
-                        IntelliTool::onMouseRightReleased(x,y);
+						IntelliTool::onMouseRightReleased(x,y);
 				}
 
 		}
-        else if(drawingOfPolygon) {
+		else if(drawingOfPolygon) {
 				QPoint drawingPoint(x,y);
 				QPointList.push_back(drawingPoint);
 				this->Canvas->image->drawLine(QPointList[QPointList.size() - 2], QPointList[QPointList.size() - 1], colorPicker->getFirstColor(), Toolsettings->getLineWidth());
-				this->Canvas->image->calculateVisiblity();
+				if(!isSettingPolygon) {
+						this->Canvas->image->calculateVisiblity();
+				}
 		}
 }
 
@@ -72,25 +87,32 @@ void IntelliToolPolygon::onMouseLeftReleased(int x, int y){
 		if(isPointNearStart) {
 				isInside = false;
 				isPointNearStart = false;
-                drawingOfPolygon = false;
-				std::vector<Triangle> Triangles = IntelliTriangulation::calculateTriangles(QPointList);
-				QPoint Point;
-				QColor colorTwo(colorPicker->getSecondColor());
-				colorTwo.setAlpha(Toolsettings->getInnerAlpha());
-				for(int i = 0; i < activeLayer->width; i++) {
-						for(int j = 0; j < activeLayer->height; j++) {
-								Point = QPoint(i,j);
-								if(IntelliTriangulation::isInPolygon(Triangles,Point)) {
-										this->Canvas->image->drawPixel(Point, colorTwo);
+				isDrawing = false;
+				if(!isSettingPolygon) {
+						std::vector<Triangle> Triangles = IntelliTriangulation::calculateTriangles(QPointList);
+						QPoint Point;
+						QColor colorTwo(colorPicker->getSecondColor());
+						colorTwo.setAlpha(Toolsettings->getInnerAlpha());
+						for(int i = 0; i < activeLayer->width; i++) {
+								for(int j = 0; j < activeLayer->height; j++) {
+										Point = QPoint(i,j);
+										if(IntelliTriangulation::isInPolygon(Triangles,Point)) {
+												this->Canvas->image->drawPixel(Point, colorTwo);
+										}
 								}
 						}
+						for(int i=0; i<static_cast<int>(QPointList.size()); i++) {
+								int next = static_cast<int>((i+static_cast<int>(1))%static_cast<int>(QPointList.size()));
+								this->Canvas->image->drawLine(QPointList[static_cast<unsigned long long>(i)], QPointList[static_cast<unsigned long long>(next)], colorPicker->getFirstColor(), Toolsettings->getLineWidth());
+						}
+
 				}
-				for(int i=0; i<static_cast<int>(QPointList.size()); i++) {
-						int next = static_cast<int>((i+static_cast<int>(1))%static_cast<int>(QPointList.size()));
-						this->Canvas->image->drawLine(QPointList[static_cast<unsigned long long>(i)], QPointList[static_cast<unsigned long long>(next)], colorPicker->getFirstColor(), Toolsettings->getLineWidth());
+				else{
+						Canvas->image->setPolygon(QPointList);
+						Canvas->image->setImageData(Area->getImageDataOfActiveLayer());
 				}
-				QPointList.clear();
 				IntelliTool::onMouseLeftReleased(x,y);
+				QPointList.clear();
 		}
 }
 
@@ -100,7 +122,7 @@ void IntelliToolPolygon::onMouseRightReleased(int x, int y){
 
 void IntelliToolPolygon::onWheelScrolled(int value){
 		IntelliTool::onWheelScrolled(value);
-        if(!drawingOfPolygon) {
+		if(!drawingOfPolygon) {
 				Toolsettings->setLineWidth(Toolsettings->getLineWidth() + value);
 		}
 }
diff --git a/src/Tool/IntelliToolPolygon.h b/src/Tool/IntelliToolPolygon.h
index fa0cea9..346844b 100644
--- a/src/Tool/IntelliToolPolygon.h
+++ b/src/Tool/IntelliToolPolygon.h
@@ -34,6 +34,11 @@ bool drawingOfPolygon;
  */
 bool isInside;
 
+/*!
+ * \brief isSettingPolygon is the flag for calling the setPolygon method.
+ */
+bool isSettingPolygon;
+
 /*!
  * \brief PointIsNearStart true, when last click near startpoint, else false.
  */
@@ -48,8 +53,9 @@ public:
  * \brief A constructor setting the general paintingArea and colorPicker.
  * \param Area          - The general paintingArea used by the project.
  * \param colorPicker   - The general colorPicker used by the project.
+ * \param isSettingPolygon - The flag for the set polygon method, standart is false
  */
-IntelliToolPolygon(PaintingArea* Area, IntelliColorPicker* colorPicker, IntelliToolsettings* Toolsettings);
+IntelliToolPolygon(PaintingArea* Area, IntelliColorPicker* colorPicker, IntelliToolsettings* Toolsettings, bool isSettingPolygon = false);
 /*!
  * \brief A Destructor.
  */
@@ -96,7 +102,6 @@ virtual void onWheelScrolled(int value) override;
  */
 virtual void onMouseMoved(int x, int y) override;
 
-
 };
 
 #endif // INTELLITOOLPOLYGON_H