New Grease Pencil object for 2D animation

This commit merge the full development done in greasepencil-object branch and include mainly the following features.

- New grease pencil object.
- New drawing engine.
- New grease pencil modes Draw/Sculpt/Edit and Weight Paint.
- New brushes for grease pencil.
- New modifiers for grease pencil.
- New shaders FX.
- New material system (replace old palettes and colors).
- Split of annotations (old grease pencil) and new grease pencil object.
- UI adapted to blender 2.8.

You can get more info here:

https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/
https://code.blender.org/2018/07/grease-pencil-status-update/

This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible.

Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.

1 files changed, 1370 insertions, 265 deletions

diff --git a/source/blender/editors/gpencil/gpencil_edit.c b/source/blender/editors/gpencil/gpencil_edit.c
index ec67b2da161..4264645b52e 100644
--- a/source/blender/editors/gpencil/gpencil_edit.c
+++ b/source/blender/editors/gpencil/gpencil_edit.c
@@ -47,6 +47,7 @@
 
 #include "BLT_translation.h"
 
+#include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
@@ -54,12 +55,19 @@
 #include "DNA_view3d_types.h"
 #include "DNA_gpencil_types.h"
 
+#include "BKE_main.h"
 #include "BKE_context.h"
+#include "BKE_global.h"
+#include "BKE_brush.h"
 #include "BKE_gpencil.h"
+#include "BKE_paint.h"
 #include "BKE_library.h"
 #include "BKE_main.h"
+#include "BKE_material.h"
+#include "BKE_object.h"
 #include "BKE_report.h"
 #include "BKE_screen.h"
+#include "BKE_workspace.h"
 
 #include "UI_interface.h"
 #include "UI_resources.h"
@@ -80,31 +88,70 @@
 #include "ED_space_api.h"
 
 #include "DEG_depsgraph.h"
+#include "DEG_depsgraph_build.h"
+#include "DEG_depsgraph_query.h"
 
 #include "gpencil_intern.h"
 
 /* ************************************************ */
 /* Stroke Edit Mode Management */
-
 static bool gpencil_editmode_toggle_poll(bContext *C)
 {
+	/* if using gpencil object, use this gpd */
+	Object *ob = CTX_data_active_object(C);
+	if ((ob) && (ob->type == OB_GPENCIL)) {
+		return ob->data != NULL;
+	}
 	return ED_gpencil_data_get_active(C) != NULL;
 }
 
-static int gpencil_editmode_toggle_exec(bContext *C, wmOperator *UNUSED(op))
+static int gpencil_editmode_toggle_exec(bContext *C, wmOperator *op)
 {
+	const int back = RNA_boolean_get(op->ptr, "back");
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);                                      \
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	bool is_object = false;
+	short mode;
+	/* if using a gpencil object, use this datablock */
+	Object *ob = CTX_data_active_object(C);
+	if ((ob) && (ob->type == OB_GPENCIL)) {
+		gpd = ob->data;
+		is_object = true;
+	}
 
-	if (gpd == NULL)
+	if (gpd == NULL) {
+		BKE_report(op->reports, RPT_ERROR, "No active GP data");
 		return OPERATOR_CANCELLED;
+	}
 
 	/* Just toggle editmode flag... */
 	gpd->flag ^= GP_DATA_STROKE_EDITMODE;
 	/* recalculate parent matrix */
 	if (gpd->flag & GP_DATA_STROKE_EDITMODE) {
-		ED_gpencil_reset_layers_parent(gpd);
+		ED_gpencil_reset_layers_parent(depsgraph, ob, gpd);
+	}
+	/* set mode */
+	if (gpd->flag & GP_DATA_STROKE_EDITMODE) {
+		mode = OB_MODE_GPENCIL_EDIT;
+	}
+	else {
+		mode = OB_MODE_OBJECT;
+	}
+
+	if (is_object) {
+		/* try to back previous mode */
+		if ((ob->restore_mode) && ((gpd->flag & GP_DATA_STROKE_EDITMODE) == 0) && (back == 1)) {
+			mode = ob->restore_mode;
+		}
+		ob->restore_mode = ob->mode;
+		ob->mode = mode;
 	}
 
+	/* setup other modes */
+	ED_gpencil_setup_modes(C, gpd, mode);
+	/* set cache as dirty */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA, NULL);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_GPENCIL_EDITMODE, NULL);
 	WM_event_add_notifier(C, NC_SCENE | ND_MODE, NULL);
@@ -114,6 +161,8 @@ static int gpencil_editmode_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 
 void GPENCIL_OT_editmode_toggle(wmOperatorType *ot)
 {
+	PropertyRNA *prop;
+
 	/* identifiers */
 	ot->name = "Strokes Edit Mode Toggle";
 	ot->idname = "GPENCIL_OT_editmode_toggle";
@@ -125,6 +174,259 @@ void GPENCIL_OT_editmode_toggle(wmOperatorType *ot)
 
 	/* flags */
 	ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER;
+
+	/* properties */
+	prop = RNA_def_boolean(ot->srna, "back", 0, "Return to Previous Mode", "Return to previous mode");
+	RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
+}
+
+/* Stroke Paint Mode Management */
+
+static bool gpencil_paintmode_toggle_poll(bContext *C)
+{
+	/* if using gpencil object, use this gpd */
+	Object *ob = CTX_data_active_object(C);
+	if ((ob) && (ob->type == OB_GPENCIL)) {
+		return ob->data != NULL;
+	}
+	return ED_gpencil_data_get_active(C) != NULL;
+}
+
+static int gpencil_paintmode_toggle_exec(bContext *C, wmOperator *op)
+{
+	const bool back = RNA_boolean_get(op->ptr, "back");
+
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	ToolSettings *ts = CTX_data_tool_settings(C);
+
+	bool is_object = false;
+	short mode;
+	/* if using a gpencil object, use this datablock */
+	Object *ob = CTX_data_active_object(C);
+	if ((ob) && (ob->type == OB_GPENCIL)) {
+		gpd = ob->data;
+		is_object = true;
+	}
+
+	if (gpd == NULL)
+		return OPERATOR_CANCELLED;
+
+	/* Just toggle paintmode flag... */
+	gpd->flag ^= GP_DATA_STROKE_PAINTMODE;
+	/* set mode */
+	if (gpd->flag & GP_DATA_STROKE_PAINTMODE) {
+		mode = OB_MODE_GPENCIL_PAINT;
+	}
+	else {
+		mode = OB_MODE_OBJECT;
+	}
+
+	if (is_object) {
+		/* try to back previous mode */
+		if ((ob->restore_mode) && ((gpd->flag & GP_DATA_STROKE_PAINTMODE) == 0) && (back == 1)) {
+			mode = ob->restore_mode;
+		}
+		ob->restore_mode = ob->mode;
+		ob->mode = mode;
+	}
+
+	/* be sure we have brushes */
+	Paint *paint = BKE_brush_get_gpencil_paint(ts);
+	/* if not exist, create a new one */
+	if (paint->brush == NULL) {
+		BKE_brush_gpencil_presets(C);
+	}
+
+	/* setup other modes */
+	ED_gpencil_setup_modes(C, gpd, mode);
+	/* set cache as dirty */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, NULL);
+	WM_event_add_notifier(C, NC_SCENE | ND_MODE, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_paintmode_toggle(wmOperatorType *ot)
+{
+	PropertyRNA *prop;
+
+	/* identifiers */
+	ot->name = "Strokes Paint Mode Toggle";
+	ot->idname = "GPENCIL_OT_paintmode_toggle";
+	ot->description = "Enter/Exit paint mode for Grease Pencil strokes";
+
+	/* callbacks */
+	ot->exec = gpencil_paintmode_toggle_exec;
+	ot->poll = gpencil_paintmode_toggle_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER;
+
+	/* properties */
+	prop = RNA_def_boolean(ot->srna, "back", 0, "Return to Previous Mode", "Return to previous mode");
+	RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
+}
+
+/* Stroke Sculpt Mode Management */
+
+static bool gpencil_sculptmode_toggle_poll(bContext *C)
+{
+	/* if using gpencil object, use this gpd */
+	Object *ob = CTX_data_active_object(C);
+	if ((ob) && (ob->type == OB_GPENCIL)) {
+		return ob->data != NULL;
+	}
+	return ED_gpencil_data_get_active(C) != NULL;
+}
+
+static int gpencil_sculptmode_toggle_exec(bContext *C, wmOperator *op)
+{
+	const bool back = RNA_boolean_get(op->ptr, "back");
+
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	bool is_object = false;
+	short mode;
+	/* if using a gpencil object, use this datablock */
+	Object *ob = CTX_data_active_object(C);
+	if ((ob) && (ob->type == OB_GPENCIL)) {
+		gpd = ob->data;
+		is_object = true;
+	}
+
+	if (gpd == NULL)
+		return OPERATOR_CANCELLED;
+
+	/* Just toggle sculptmode flag... */
+	gpd->flag ^= GP_DATA_STROKE_SCULPTMODE;
+	/* set mode */
+	if (gpd->flag & GP_DATA_STROKE_SCULPTMODE) {
+		mode = OB_MODE_GPENCIL_SCULPT;
+	}
+	else {
+		mode = OB_MODE_OBJECT;
+	}
+
+	if (is_object) {
+		/* try to back previous mode */
+		if ((ob->restore_mode) && ((gpd->flag & GP_DATA_STROKE_SCULPTMODE) == 0) && (back == 1)) {
+			mode = ob->restore_mode;
+		}
+		ob->restore_mode = ob->mode;
+		ob->mode = mode;
+	}
+
+	/* setup other modes */
+	ED_gpencil_setup_modes(C, gpd, mode);
+	/* set cache as dirty */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, NULL);
+	WM_event_add_notifier(C, NC_SCENE | ND_MODE, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_sculptmode_toggle(wmOperatorType *ot)
+{
+	PropertyRNA *prop;
+
+	/* identifiers */
+	ot->name = "Strokes Sculpt Mode Toggle";
+	ot->idname = "GPENCIL_OT_sculptmode_toggle";
+	ot->description = "Enter/Exit sculpt mode for Grease Pencil strokes";
+
+	/* callbacks */
+	ot->exec = gpencil_sculptmode_toggle_exec;
+	ot->poll = gpencil_sculptmode_toggle_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER;
+
+	/* properties */
+	prop = RNA_def_boolean(ot->srna, "back", 0, "Return to Previous Mode", "Return to previous mode");
+	RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
+}
+
+/* Stroke Weight Paint Mode Management */
+
+static bool gpencil_weightmode_toggle_poll(bContext *C)
+{
+	/* if using gpencil object, use this gpd */
+	Object *ob = CTX_data_active_object(C);
+	if ((ob) && (ob->type == OB_GPENCIL)) {
+		return ob->data != NULL;
+	}
+	return ED_gpencil_data_get_active(C) != NULL;
+}
+
+static int gpencil_weightmode_toggle_exec(bContext *C, wmOperator *op)
+{
+	const bool back = RNA_boolean_get(op->ptr, "back");
+
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	bool is_object = false;
+	short mode;
+	/* if using a gpencil object, use this datablock */
+	Object *ob = CTX_data_active_object(C);
+	if ((ob) && (ob->type == OB_GPENCIL)) {
+		gpd = ob->data;
+		is_object = true;
+	}
+
+	if (gpd == NULL)
+		return OPERATOR_CANCELLED;
+
+	/* Just toggle weightmode flag... */
+	gpd->flag ^= GP_DATA_STROKE_WEIGHTMODE;
+	/* set mode */
+	if (gpd->flag & GP_DATA_STROKE_WEIGHTMODE) {
+		mode = OB_MODE_GPENCIL_WEIGHT;
+	}
+	else {
+		mode = OB_MODE_OBJECT;
+	}
+
+	if (is_object) {
+		/* try to back previous mode */
+		if ((ob->restore_mode) && ((gpd->flag & GP_DATA_STROKE_WEIGHTMODE) == 0) && (back == 1)) {
+			mode = ob->restore_mode;
+		}
+		ob->restore_mode = ob->mode;
+		ob->mode = mode;
+	}
+
+	/* setup other modes */
+	ED_gpencil_setup_modes(C, gpd, mode);
+	/* set cache as dirty */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, NULL);
+	WM_event_add_notifier(C, NC_SCENE | ND_MODE, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_weightmode_toggle(wmOperatorType *ot)
+{
+	PropertyRNA *prop;
+
+	/* identifiers */
+	ot->name = "Strokes Weight Mode Toggle";
+	ot->idname = "GPENCIL_OT_weightmode_toggle";
+	ot->description = "Enter/Exit weight paint mode for Grease Pencil strokes";
+
+	/* callbacks */
+	ot->exec = gpencil_weightmode_toggle_exec;
+	ot->poll = gpencil_weightmode_toggle_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER;
+
+	/* properties */
+	prop = RNA_def_boolean(ot->srna, "back", 0, "Return to Previous Mode", "Return to previous mode");
+	RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
 }
 
 /* ************************************************ */
@@ -137,21 +439,30 @@ static bool gp_stroke_edit_poll(bContext *C)
 	return CTX_DATA_COUNT(C, editable_gpencil_strokes) != 0;
 }
 
+/* poll callback to verify edit mode in 3D view only */
+static bool gp_strokes_edit3d_poll(bContext *C)
+{
+	/* 2 Requirements:
+	*  - 1) Editable GP data
+	*  - 2) 3D View only
+	*/
+	return (gp_stroke_edit_poll(C) && ED_operator_view3d_active(C));
+}
+
 /* ************ Stroke Hide selection Toggle ************** */
 
 static int gpencil_hideselect_toggle_exec(bContext *C, wmOperator *UNUSED(op))
 {
-	ToolSettings *ts = CTX_data_tool_settings(C);
-
-	if (ts == NULL)
+	View3D *v3d = CTX_wm_view3d(C);
+	if (v3d == NULL)
 		return OPERATOR_CANCELLED;
 
 	/* Just toggle alpha... */
-	if (ts->gp_sculpt.alpha > 0.0f) {
-		ts->gp_sculpt.alpha = 0.0f;
+	if (v3d->vertex_opacity > 0.0f) {
+		v3d->vertex_opacity = 0.0f;
 	}
 	else {
-		ts->gp_sculpt.alpha = 1.0f;
+		v3d->vertex_opacity = 1.0f;
 	}
 
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA, NULL);
@@ -176,6 +487,44 @@ void GPENCIL_OT_selection_opacity_toggle(wmOperatorType *ot)
 	ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER;
 }
 
+/* toggle multi edit strokes support */
+static int gpencil_multiedit_toggle_exec(bContext *C, wmOperator *op)
+{
+	View3D *v3d = CTX_wm_view3d(C);
+	const bool lines = RNA_boolean_get(op->ptr, "lines");
+
+	/* Just toggle value */
+	if (lines == 0) {
+		v3d->flag3 ^= V3D_GP_SHOW_EDIT_LINES;
+	}
+	else {
+		v3d->flag3 ^= V3D_GP_SHOW_MULTIEDIT_LINES;
+	}
+
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, NULL);
+	WM_event_add_notifier(C, NC_SCENE | ND_MODE, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_multiedit_toggle(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Edit Lines Toggle";
+	ot->idname = "GPENCIL_OT_multiedit_toggle";
+	ot->description = "Enable/disable edit lines support";
+
+	/* callbacks */
+	ot->exec = gpencil_multiedit_toggle_exec;
+	ot->poll = gp_stroke_edit_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER;
+
+	/* properties */
+	RNA_def_boolean(ot->srna, "toggle_visibility", 0, "Toggle Visibility Only", "Toggle visibility of edit lines only");
+}
+
 /* ************** Duplicate Selected Strokes **************** */
 
 /* Make copies of selected point segments in a selected stroke */
@@ -220,7 +569,7 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes, co
 
 				/* make a stupid copy first of the entire stroke (to get the flags too) */
 				gpsd = MEM_dupallocN(gps);
-				BLI_strncpy(gpsd->tmp_layerinfo, layername, sizeof(gpsd->tmp_layerinfo)); /* saves original layer name */
+				BLI_strncpy(gpsd->runtime.tmp_layerinfo, layername, sizeof(gpsd->runtime.tmp_layerinfo)); /* saves original layer name */
 
 				/* initialize triangle memory - will be calculated on next redraw */
 				gpsd->triangles = NULL;
@@ -232,6 +581,20 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes, co
 				memcpy(gpsd->points, gps->points + start_idx, sizeof(bGPDspoint) * len);
 				gpsd->totpoints = len;
 
+				if (gps->dvert != NULL) {
+					gpsd->dvert = MEM_callocN(sizeof(MDeformVert) * len, "gps stroke weights copy");
+					memcpy(gpsd->dvert, gps->dvert + start_idx, sizeof(MDeformVert) * len);
+
+					/* Copy weights */
+					int e = start_idx;
+					for (int j = 0; j < gpsd->totpoints; j++) {
+						MDeformVert *dvert_dst = &gps->dvert[e];
+						MDeformVert *dvert_src = &gps->dvert[j];
+						dvert_dst->dw = MEM_dupallocN(dvert_src->dw);
+						e++;
+					}
+				}
+
 				/* add to temp buffer */
 				gpsd->next = gpsd->prev = NULL;
 				BLI_addtail(new_strokes, gpsd);
@@ -252,6 +615,11 @@ static int gp_duplicate_exec(bContext *C, wmOperator *op)
 		return OPERATOR_CANCELLED;
 	}
 
+	if (GPENCIL_MULTIEDIT_SESSIONS_ON(gpd)) {
+		BKE_report(op->reports, RPT_ERROR, "Operator not supported in multiframe edition");
+		return OPERATOR_CANCELLED;
+	}
+
 	/* for each visible (and editable) layer's selected strokes,
 	 * copy the strokes into a temporary buffer, then append
 	 * once all done
@@ -279,8 +647,12 @@ static int gp_duplicate_exec(bContext *C, wmOperator *op)
 
 					/* make direct copies of the stroke and its points */
 					gpsd = MEM_dupallocN(gps);
-					BLI_strncpy(gpsd->tmp_layerinfo, gpl->info, sizeof(gpsd->tmp_layerinfo));
+					BLI_strncpy(gpsd->runtime.tmp_layerinfo, gpl->info, sizeof(gpsd->runtime.tmp_layerinfo));
 					gpsd->points = MEM_dupallocN(gps->points);
+					if (gps->dvert != NULL) {
+						gpsd->dvert = MEM_dupallocN(gps->dvert);
+						BKE_gpencil_stroke_weights_duplicate(gps, gpsd);
+					}
 
 					/* triangle information - will be calculated on next redraw */
 					gpsd->flag |= GP_STROKE_RECALC_CACHES;
@@ -309,6 +681,7 @@ static int gp_duplicate_exec(bContext *C, wmOperator *op)
 	CTX_DATA_END;
 
 	/* updates */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -342,7 +715,7 @@ void GPENCIL_OT_duplicate(wmOperatorType *ot)
 /* NOTE: is exposed within the editors/gpencil module so that other tools can use it too */
 ListBase gp_strokes_copypastebuf = {NULL, NULL};
 
-/* Hash for hanging on to all the palette colors used by strokes in the buffer
+/* Hash for hanging on to all the colors used by strokes in the buffer
  *
  * This is needed to prevent dangling and unsafe pointers when pasting across datablocks,
  * or after a color used by a stroke in the buffer gets deleted (via user action or undo).
@@ -354,11 +727,11 @@ void ED_gpencil_strokes_copybuf_free(void)
 {
 	bGPDstroke *gps, *gpsn;
 
-	/* Free the palettes buffer
-	 * NOTE: This is done before the strokes so that the name ptrs (keys) are still safe
+	/* Free the colors buffer
+	 * NOTE: This is done before the strokes so that the ptrs are still safe
 	 */
 	if (gp_strokes_copypastebuf_colors) {
-		BLI_ghash_free(gp_strokes_copypastebuf_colors, NULL, MEM_freeN);
+		BLI_ghash_free(gp_strokes_copypastebuf_colors, NULL, NULL);
 		gp_strokes_copypastebuf_colors = NULL;
 	}
 
@@ -366,8 +739,15 @@ void ED_gpencil_strokes_copybuf_free(void)
 	for (gps = gp_strokes_copypastebuf.first; gps; gps = gpsn) {
 		gpsn = gps->next;
 
-		if (gps->points)    MEM_freeN(gps->points);
-		if (gps->triangles) MEM_freeN(gps->triangles);
+		if (gps->points) {
+			MEM_freeN(gps->points);
+		}
+		if (gps->dvert) {
+			BKE_gpencil_free_stroke_weights(gps);
+			MEM_freeN(gps->dvert);
+		}
+
+		MEM_SAFE_FREE(gps->triangles);
 
 		BLI_freelinkN(&gp_strokes_copypastebuf, gps);
 	}
@@ -378,38 +758,26 @@ void ED_gpencil_strokes_copybuf_free(void)
 /* Ensure that destination datablock has all the colours the pasted strokes need
  * Helper function for copy-pasting strokes
  */
-GHash *gp_copybuf_validate_colormap(bGPdata *gpd)
+GHash *gp_copybuf_validate_colormap(bContext *C)
 {
+	Main *bmain = CTX_data_main(C);
+	Object *ob = CTX_data_active_object(C);
 	GHash *new_colors = BLI_ghash_str_new("GPencil Paste Dst Colors");
 	GHashIterator gh_iter;
 
-	/* If there's no active palette yet (i.e. new datablock), add one */
-	bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
-	if (palette == NULL) {
-		palette = BKE_gpencil_palette_addnew(gpd, "Pasted Palette", true);
-	}
-
-	/* For each color, figure out what to map to... */
+	/* For each color, check if exist and add if not */
 	GHASH_ITER(gh_iter, gp_strokes_copypastebuf_colors) {
-		bGPDpalettecolor *palcolor;
-		char *name = BLI_ghashIterator_getKey(&gh_iter);
-
-		/* Look for existing color to map to */
-		/* XXX: What to do if same name but different color? Behaviour here should depend on a property? */
-		palcolor = BKE_gpencil_palettecolor_getbyname(palette, name);
-		if (palcolor == NULL) {
-			/* Doesn't Exist - Create new matching color for this palette */
-			/* XXX: This still doesn't fix the pasting across file boundaries problem... */
-			bGPDpalettecolor *src_color = BLI_ghashIterator_getValue(&gh_iter);
 
-			palcolor = MEM_dupallocN(src_color);
-			BLI_addtail(&palette->colors, palcolor);
+		int *key = BLI_ghashIterator_getKey(&gh_iter);
+		Material *ma = BLI_ghashIterator_getValue(&gh_iter);
 
-			BLI_uniquename(&palette->colors, palcolor, DATA_("GP Color"), '.', offsetof(bGPDpalettecolor, info), sizeof(palcolor->info));
+		if (BKE_object_material_slot_find_index(ob, ma) == 0) {
+			BKE_object_material_slot_add(bmain, ob);
+			assign_material(bmain, ob, ma, ob->totcol, BKE_MAT_ASSIGN_EXISTING);
 		}
 
 		/* Store this mapping (for use later when pasting) */
-		BLI_ghash_insert(new_colors, name, palcolor);
+		BLI_ghash_insert(new_colors, key, ma);
 	}
 
 	return new_colors;
@@ -420,6 +788,7 @@ GHash *gp_copybuf_validate_colormap(bGPdata *gpd)
 
 static int gp_strokes_copy_exec(bContext *C, wmOperator *op)
 {
+	Object *ob = CTX_data_active_object(C);
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
 
 	if (gpd == NULL) {
@@ -427,6 +796,11 @@ static int gp_strokes_copy_exec(bContext *C, wmOperator *op)
 		return OPERATOR_CANCELLED;
 	}
 
+	if (GPENCIL_MULTIEDIT_SESSIONS_ON(gpd)) {
+		BKE_report(op->reports, RPT_ERROR, "Operator not supported in multiframe edition");
+		return OPERATOR_CANCELLED;
+	}
+
 	/* clear the buffer first */
 	ED_gpencil_strokes_copybuf_free();
 
@@ -455,8 +829,12 @@ static int gp_strokes_copy_exec(bContext *C, wmOperator *op)
 
 					/* make direct copies of the stroke and its points */
 					gpsd = MEM_dupallocN(gps);
-					BLI_strncpy(gpsd->tmp_layerinfo, gpl->info, sizeof(gpsd->tmp_layerinfo)); /* saves original layer name */
+					BLI_strncpy(gpsd->runtime.tmp_layerinfo, gpl->info, sizeof(gpsd->runtime.tmp_layerinfo)); /* saves original layer name */
 					gpsd->points = MEM_dupallocN(gps->points);
+					if (gps->dvert != NULL) {
+						gpsd->dvert = MEM_dupallocN(gps->dvert);
+						BKE_gpencil_stroke_weights_duplicate(gps, gpsd);
+					}
 
 					/* triangles cache - will be recalculated on next redraw */
 					gpsd->flag |= GP_STROKE_RECALC_CACHES;
@@ -476,17 +854,16 @@ static int gp_strokes_copy_exec(bContext *C, wmOperator *op)
 	}
 	CTX_DATA_END;
 
-	/* Build up hash of colors used in these strokes, making copies of these to protect against dangling pointers */
+	/* Build up hash of material colors used in these strokes */
 	if (gp_strokes_copypastebuf.first) {
 		gp_strokes_copypastebuf_colors = BLI_ghash_str_new("GPencil CopyBuf Colors");
-
+		Material *ma = NULL;
 		for (bGPDstroke *gps = gp_strokes_copypastebuf.first; gps; gps = gps->next) {
 			if (ED_gpencil_stroke_can_use(C, gps)) {
-				if (BLI_ghash_haskey(gp_strokes_copypastebuf_colors, gps->colorname) == false) {
-					bGPDpalettecolor *color = MEM_dupallocN(gps->palcolor);
-
-					BLI_ghash_insert(gp_strokes_copypastebuf_colors, gps->colorname, color);
-					gps->palcolor = color;
+				ma = give_current_material(ob, gps->mat_nr + 1);
+				if (BLI_ghash_haskey(gp_strokes_copypastebuf_colors, &gps->mat_nr) == false)
+				{
+					BLI_ghash_insert(gp_strokes_copypastebuf_colors, &gps->mat_nr, ma);
 				}
 			}
 		}
@@ -534,9 +911,11 @@ typedef enum eGP_PasteMode {
 
 static int gp_strokes_paste_exec(bContext *C, wmOperator *op)
 {
-	Scene *scene = CTX_data_scene(C);
+	Object *ob = CTX_data_active_object(C);
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
 	bGPDlayer *gpl = CTX_data_active_gpencil_layer(C); /* only use active for copy merge */
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);
+	int cfra_eval = (int)DEG_get_ctime(depsgraph);
 	bGPDframe *gpf;
 
 	eGP_PasteMode type = RNA_enum_get(op->ptr, "type");
@@ -547,6 +926,10 @@ static int gp_strokes_paste_exec(bContext *C, wmOperator *op)
 		BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data");
 		return OPERATOR_CANCELLED;
 	}
+	else if (GPENCIL_MULTIEDIT_SESSIONS_ON(gpd)) {
+		BKE_report(op->reports, RPT_ERROR, "Operator not supported in multiframe edition");
+		return OPERATOR_CANCELLED;
+	}
 	else if (BLI_listbase_is_empty(&gp_strokes_copypastebuf)) {
 		BKE_report(op->reports, RPT_ERROR, "No strokes to paste, select and copy some points before trying again");
 		return OPERATOR_CANCELLED;
@@ -599,14 +982,14 @@ static int gp_strokes_paste_exec(bContext *C, wmOperator *op)
 	CTX_DATA_END;
 
 	/* Ensure that all the necessary colors exist */
-	new_colors = gp_copybuf_validate_colormap(gpd);
+	new_colors = gp_copybuf_validate_colormap(C);
 
 	/* Copy over the strokes from the buffer (and adjust the colors) */
 	for (bGPDstroke *gps = gp_strokes_copypastebuf.first; gps; gps = gps->next) {
 		if (ED_gpencil_stroke_can_use(C, gps)) {
 			/* Need to verify if layer exists */
 			if (type != GP_COPY_MERGE) {
-				gpl = BLI_findstring(&gpd->layers, gps->tmp_layerinfo, offsetof(bGPDlayer, info));
+				gpl = BLI_findstring(&gpd->layers, gps->runtime.tmp_layerinfo, offsetof(bGPDlayer, info));
 				if (gpl == NULL) {
 					/* no layer - use active (only if layer deleted before paste) */
 					gpl = CTX_data_active_gpencil_layer(C);
@@ -618,28 +1001,33 @@ static int gp_strokes_paste_exec(bContext *C, wmOperator *op)
 			 *       we are obliged to add a new frame if one
 			 *       doesn't exist already
 			 */
-			gpf = BKE_gpencil_layer_getframe(gpl, CFRA, true);
+			gpf = BKE_gpencil_layer_getframe(gpl, cfra_eval, true);
 			if (gpf) {
 				/* Create new stroke */
 				bGPDstroke *new_stroke = MEM_dupallocN(gps);
-				new_stroke->tmp_layerinfo[0] = '\0';
+				new_stroke->runtime.tmp_layerinfo[0] = '\0';
 
 				new_stroke->points = MEM_dupallocN(gps->points);
-
+				if (gps->dvert != NULL) {
+					new_stroke->dvert = MEM_dupallocN(gps->dvert);
+					BKE_gpencil_stroke_weights_duplicate(gps, new_stroke);
+				}
 				new_stroke->flag |= GP_STROKE_RECALC_CACHES;
 				new_stroke->triangles = NULL;
 
 				new_stroke->next = new_stroke->prev = NULL;
 				BLI_addtail(&gpf->strokes, new_stroke);
 
-				/* Fix color references */
-				BLI_assert(new_stroke->colorname[0] != '\0');
-				new_stroke->palcolor = BLI_ghash_lookup(new_colors, new_stroke->colorname);
-
-				BLI_assert(new_stroke->palcolor != NULL);
-				BLI_strncpy(new_stroke->colorname, new_stroke->palcolor->info, sizeof(new_stroke->colorname));
+				/* Remap material */
+				Material *ma = BLI_ghash_lookup(new_colors, &new_stroke->mat_nr);
+				if ((ma) && (BKE_object_material_slot_find_index(ob, ma) > 0)) {
+					gps->mat_nr = BKE_object_material_slot_find_index(ob, ma) - 1;
+					CLAMP_MIN(gps->mat_nr, 0);
+				}
+				else {
+					gps->mat_nr = 0; /* only if the color is not found */
+				}
 
-				/*new_stroke->flag |= GP_STROKE_RECALC_COLOR; */
 			}
 		}
 	}
@@ -648,6 +1036,7 @@ static int gp_strokes_paste_exec(bContext *C, wmOperator *op)
 	BLI_ghash_free(new_colors, NULL, NULL);
 
 	/* updates */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -697,10 +1086,17 @@ static int gp_move_to_layer_invoke(bContext *C, wmOperator *op, const wmEvent *U
 static int gp_move_to_layer_exec(bContext *C, wmOperator *op)
 {
 	bGPdata *gpd = CTX_data_gpencil_data(C);
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);
+	int cfra_eval = (int)DEG_get_ctime(depsgraph);
 	bGPDlayer *target_layer = NULL;
 	ListBase strokes = {NULL, NULL};
 	int layer_num = RNA_enum_get(op->ptr, "layer");
 
+	if (GPENCIL_MULTIEDIT_SESSIONS_ON(gpd)) {
+		BKE_report(op->reports, RPT_ERROR, "Operator not supported in multiframe edition");
+		return OPERATOR_CANCELLED;
+	}
+
 	/* Get layer or create new one */
 	if (layer_num == -1) {
 		/* Create layer */
@@ -748,14 +1144,14 @@ static int gp_move_to_layer_exec(bContext *C, wmOperator *op)
 
 	/* Paste them all in one go */
 	if (strokes.first) {
-		Scene *scene = CTX_data_scene(C);
-		bGPDframe *gpf = BKE_gpencil_layer_getframe(target_layer, CFRA, true);
+		bGPDframe *gpf = BKE_gpencil_layer_getframe(target_layer, cfra_eval, true);
 
 		BLI_movelisttolist(&gpf->strokes, &strokes);
 		BLI_assert((strokes.first == strokes.last) && (strokes.first == NULL));
 	}
 
 	/* updates */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -804,8 +1200,10 @@ static bool UNUSED_FUNCTION(gp_blank_frame_add_poll)(bContext *C)
 
 static int gp_blank_frame_add_exec(bContext *C, wmOperator *op)
 {
-	Scene *scene = CTX_data_scene(C);
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);
+	int cfra_eval = (int)DEG_get_ctime(depsgraph);
+
 	bGPDlayer *active_gpl = BKE_gpencil_layer_getactive(gpd);
 
 	const bool all_layers = RNA_boolean_get(op->ptr, "all_layers");
@@ -826,7 +1224,7 @@ static int gp_blank_frame_add_exec(bContext *C, wmOperator *op)
 		}
 
 		/* 1) Check for an existing frame on the current frame */
-		bGPDframe *gpf = BKE_gpencil_layer_find_frame(gpl, CFRA);
+		bGPDframe *gpf = BKE_gpencil_layer_find_frame(gpl, cfra_eval);
 		if (gpf) {
 			/* Shunt all frames after (and including) the existing one later by 1-frame */
 			for (; gpf; gpf = gpf->next) {
@@ -835,11 +1233,12 @@ static int gp_blank_frame_add_exec(bContext *C, wmOperator *op)
 		}
 
 		/* 2) Now add a new frame, with nothing in it */
-		gpl->actframe = BKE_gpencil_layer_getframe(gpl, CFRA, GP_GETFRAME_ADD_NEW);
+		gpl->actframe = BKE_gpencil_layer_getframe(gpl, cfra_eval, GP_GETFRAME_ADD_NEW);
 	}
 	CTX_DATA_END;
 
 	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -876,10 +1275,13 @@ static bool gp_actframe_delete_poll(bContext *C)
 /* delete active frame - wrapper around API calls */
 static int gp_actframe_delete_exec(bContext *C, wmOperator *op)
 {
-	Scene *scene = CTX_data_scene(C);
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
 	bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
-	bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0);
+
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);
+	int cfra_eval = (int)DEG_get_ctime(depsgraph);
+
+	bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, cfra_eval, 0);
 
 	/* if there's no existing Grease-Pencil data there, add some */
 	if (gpd == NULL) {
@@ -895,6 +1297,7 @@ static int gp_actframe_delete_exec(bContext *C, wmOperator *op)
 	BKE_gpencil_layer_delframe(gpl, gpf);
 
 	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -928,13 +1331,16 @@ static bool gp_actframe_delete_all_poll(bContext *C)
 
 static int gp_actframe_delete_all_exec(bContext *C, wmOperator *op)
 {
-	Scene *scene = CTX_data_scene(C);
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);
+	int cfra_eval = (int)DEG_get_ctime(depsgraph);
+
 	bool success = false;
 
 	CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
 	{
 		/* try to get the "active" frame - but only if it actually occurs on this frame */
-		bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0);
+		bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, cfra_eval, 0);
 
 		if (gpf == NULL)
 			continue;
@@ -949,6 +1355,7 @@ static int gp_actframe_delete_all_exec(bContext *C, wmOperator *op)
 
 	/* updates */
 	if (success) {
+		DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 		WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 		return OPERATOR_FINISHED;
 	}
@@ -983,43 +1390,69 @@ typedef enum eGP_DeleteMode {
 	GP_DELETEOP_FRAME           = 2,
 } eGP_DeleteMode;
 
+typedef enum eGP_DissolveMode {
+	/* dissolve all selected points */
+	GP_DISSOLVE_POINTS = 0,
+	/* dissolve between selected points */
+	GP_DISSOLVE_BETWEEN = 1,
+	/* dissolve unselected points */
+	GP_DISSOLVE_UNSELECT = 2,
+} eGP_DissolveMode;
+
 /* ----------------------------------- */
 
 /* Delete selected strokes */
 static int gp_delete_selected_strokes(bContext *C)
 {
 	bool changed = false;
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
 
 	CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
 	{
-		bGPDframe *gpf = gpl->actframe;
-		bGPDstroke *gps, *gpsn;
+		bGPDframe *init_gpf = gpl->actframe;
+		if (is_multiedit) {
+			init_gpf = gpl->frames.first;
+		}
 
-		if (gpf == NULL)
-			continue;
+		for (bGPDframe *gpf = init_gpf; gpf; gpf = gpf->next) {
+			if ((gpf == gpl->actframe) || ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
+				bGPDstroke *gps, *gpsn;
 
-		/* simply delete strokes which are selected */
-		for (gps = gpf->strokes.first; gps; gps = gpsn) {
-			gpsn = gps->next;
+				if (gpf == NULL)
+					continue;
 
-			/* skip strokes that are invalid for current view */
-			if (ED_gpencil_stroke_can_use(C, gps) == false)
-				continue;
+				/* simply delete strokes which are selected */
+				for (gps = gpf->strokes.first; gps; gps = gpsn) {
+					gpsn = gps->next;
 
-			/* free stroke if selected */
-			if (gps->flag & GP_STROKE_SELECT) {
-				/* free stroke memory arrays, then stroke itself */
-				if (gps->points) MEM_freeN(gps->points);
-				if (gps->triangles) MEM_freeN(gps->triangles);
-				BLI_freelinkN(&gpf->strokes, gps);
+					/* skip strokes that are invalid for current view */
+					if (ED_gpencil_stroke_can_use(C, gps) == false)
+						continue;
 
-				changed = true;
+					/* free stroke if selected */
+					if (gps->flag & GP_STROKE_SELECT) {
+						/* free stroke memory arrays, then stroke itself */
+						if (gps->points) {
+							MEM_freeN(gps->points);
+						}
+						if (gps->dvert) {
+							BKE_gpencil_free_stroke_weights(gps);
+							MEM_freeN(gps->dvert);
+						}
+						MEM_SAFE_FREE(gps->triangles);
+						BLI_freelinkN(&gpf->strokes, gps);
+
+						changed = true;
+					}
+				}
 			}
 		}
 	}
 	CTX_DATA_END;
 
 	if (changed) {
+		DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 		WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 		return OPERATOR_FINISHED;
 	}
@@ -1031,88 +1464,238 @@ static int gp_delete_selected_strokes(bContext *C)
 /* ----------------------------------- */
 
 /* Delete selected points but keep the stroke */
-static int gp_dissolve_selected_points(bContext *C)
+static int gp_dissolve_selected_points(bContext *C, eGP_DissolveMode mode)
 {
+	Object *ob = CTX_data_active_object(C);
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
 	bool changed = false;
+	int first = 0;
+	int last = 0;
 
 	CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
 	{
-		bGPDframe *gpf = gpl->actframe;
-		bGPDstroke *gps, *gpsn;
+		bGPDframe *init_gpf = gpl->actframe;
+		if (is_multiedit) {
+			init_gpf = gpl->frames.first;
+		}
 
-		if (gpf == NULL)
-			continue;
+		for (bGPDframe *gpf = init_gpf; gpf; gpf = gpf->next) {
+			if ((gpf == gpl->actframe) || ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
 
-		/* simply delete points from selected strokes
-		 * NOTE: we may still have to remove the stroke if it ends up having no points!
-		 */
-		for (gps = gpf->strokes.first; gps; gps = gpsn) {
-			gpsn = gps->next;
+				bGPDstroke *gps, *gpsn;
 
-			/* skip strokes that are invalid for current view */
-			if (ED_gpencil_stroke_can_use(C, gps) == false)
-				continue;
-			/* check if the color is editable */
-			if (ED_gpencil_stroke_color_use(gpl, gps) == false)
-				continue;
+				if (gpf == NULL)
+					continue;
 
-			if (gps->flag & GP_STROKE_SELECT) {
-				bGPDspoint *pt;
-				int i;
+				/* simply delete points from selected strokes
+				 * NOTE: we may still have to remove the stroke if it ends up having no points!
+				 */
+				for (gps = gpf->strokes.first; gps; gps = gpsn) {
+					gpsn = gps->next;
+
+					/* skip strokes that are invalid for current view */
+					if (ED_gpencil_stroke_can_use(C, gps) == false)
+						continue;
+					/* check if the color is editable */
+					if (ED_gpencil_stroke_color_use(ob, gpl, gps) == false)
+						continue;
+
+					/* the stroke must have at least one point selected for any operator */
+					if (gps->flag & GP_STROKE_SELECT) {
+						bGPDspoint *pt;
+						MDeformVert *dvert = NULL;
+						int i;
+
+						int tot = gps->totpoints; /* number of points in new buffer */
+
+						/* first pass: count points to remove */
+						switch (mode) {
+							case GP_DISSOLVE_POINTS:
+								/* Count how many points are selected (i.e. how many to remove) */
+								for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
+									if (pt->flag & GP_SPOINT_SELECT) {
+										/* selected point - one of the points to remove */
+										tot--;
+									}
+								}
+								break;
+							case GP_DISSOLVE_BETWEEN:
+								/* need to find first and last point selected */
+								first = -1;
+								last = 0;
+								for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
+									if (pt->flag & GP_SPOINT_SELECT) {
+										if (first < 0) {
+											first = i;
+										}
+										last = i;
+									}
+								}
+								/* count unselected points in the range */
+								for (i = first, pt = gps->points + first; i < last; i++, pt++) {
+									if ((pt->flag & GP_SPOINT_SELECT) == 0) {
+										tot--;
+									}
+								}
+								break;
+							case GP_DISSOLVE_UNSELECT:
+								/* count number of unselected points */
+								for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
+									if ((pt->flag & GP_SPOINT_SELECT) == 0) {
+										tot--;
+									}
+								}
+								break;
+							default:
+								return false;
+								break;
+						}
 
-				int tot = gps->totpoints; /* number of points in new buffer */
+						/* if no points are left, we simply delete the entire stroke */
+						if (tot <= 0) {
+							/* remove the entire stroke */
+							if (gps->points) {
+								MEM_freeN(gps->points);
+							}
+							if (gps->dvert) {
+								BKE_gpencil_free_stroke_weights(gps);
+								MEM_freeN(gps->dvert);
+							}
+							if (gps->triangles) {
+								MEM_freeN(gps->triangles);
+							}
+							BLI_freelinkN(&gpf->strokes, gps);
+							DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+						}
+						else {
+							/* just copy all points to keep into a smaller buffer */
+							bGPDspoint *new_points = MEM_callocN(sizeof(bGPDspoint) * tot, "new gp stroke points copy");
+							bGPDspoint *npt = new_points;
 
-				/* First Pass: Count how many points are selected (i.e. how many to remove) */
-				for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
-					if (pt->flag & GP_SPOINT_SELECT) {
-						/* selected point - one of the points to remove */
-						tot--;
-					}
-				}
+							MDeformVert *new_dvert = NULL;
+							MDeformVert *ndvert = NULL;
 
-				/* if no points are left, we simply delete the entire stroke */
-				if (tot <= 0) {
-					/* remove the entire stroke */
-					MEM_freeN(gps->points);
-					if (gps->triangles) {
-						MEM_freeN(gps->triangles);
-					}
-					BLI_freelinkN(&gpf->strokes, gps);
-				}
-				else {
-					/* just copy all unselected into a smaller buffer */
-					bGPDspoint *new_points = MEM_callocN(sizeof(bGPDspoint) * tot, "new gp stroke points copy");
-					bGPDspoint *npt        = new_points;
+							if (gps->dvert != NULL) {
+								new_dvert = MEM_callocN(sizeof(MDeformVert) * tot, "new gp stroke weights copy");
+								ndvert = new_dvert;
+							}
 
-					for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
-						if ((pt->flag & GP_SPOINT_SELECT) == 0) {
-							*npt = *pt;
-							npt++;
-						}
-					}
+							switch (mode) {
+								case GP_DISSOLVE_POINTS:
+									(gps->dvert != NULL) ? dvert = gps->dvert : NULL;
+									for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
+										if ((pt->flag & GP_SPOINT_SELECT) == 0) {
+											*npt = *pt;
+											npt++;
+
+											if (gps->dvert != NULL) {
+												*ndvert = *dvert;
+												ndvert->dw = MEM_dupallocN(dvert->dw);
+												ndvert++;
+												dvert++;
+											}
+										}
+									}
+									break;
+								case GP_DISSOLVE_BETWEEN:
+									/* copy first segment */
+									(gps->dvert != NULL) ? dvert = gps->dvert : NULL;
+									for (i = 0, pt = gps->points; i < first; i++, pt++) {
+										*npt = *pt;
+										npt++;
+
+										if (gps->dvert != NULL) {
+											*ndvert = *dvert;
+											ndvert->dw = MEM_dupallocN(dvert->dw);
+											ndvert++;
+											dvert++;
+										}
+									}
+									/* copy segment (selected points) */
+									(gps->dvert != NULL) ? dvert = gps->dvert + first : NULL;
+									for (i = first, pt = gps->points + first; i < last; i++, pt++) {
+										if (pt->flag & GP_SPOINT_SELECT) {
+											*npt = *pt;
+											npt++;
+
+											if (gps->dvert != NULL) {
+												*ndvert = *dvert;
+												ndvert->dw = MEM_dupallocN(dvert->dw);
+												ndvert++;
+												dvert++;
+											}
+										}
+									}
+									/* copy last segment */
+									(gps->dvert != NULL) ? dvert = gps->dvert + last : NULL;
+									for (i = last, pt = gps->points + last; i < gps->totpoints; i++, pt++) {
+										*npt = *pt;
+										npt++;
+
+										if (gps->dvert != NULL) {
+											*ndvert = *dvert;
+											ndvert->dw = MEM_dupallocN(dvert->dw);
+											ndvert++;
+											dvert++;
+										}
+									}
+
+									break;
+								case GP_DISSOLVE_UNSELECT:
+									/* copy any selected point */
+									(gps->dvert != NULL) ? dvert = gps->dvert : NULL;
+									for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
+										if (pt->flag & GP_SPOINT_SELECT) {
+											*npt = *pt;
+											npt++;
+
+											if (gps->dvert != NULL) {
+												*ndvert = *dvert;
+												ndvert->dw = MEM_dupallocN(dvert->dw);
+												ndvert++;
+												dvert++;
+											}
+										}
+									}
+									break;
+							}
 
-					/* free the old buffer */
-					MEM_freeN(gps->points);
+							/* free the old buffer */
+							if (gps->points) {
+								MEM_freeN(gps->points);
+							}
+							if (gps->dvert) {
+								BKE_gpencil_free_stroke_weights(gps);
+								MEM_freeN(gps->dvert);
+							}
 
-					/* save the new buffer */
-					gps->points = new_points;
-					gps->totpoints = tot;
+							/* save the new buffer */
+							gps->points = new_points;
+							gps->dvert = new_dvert;
+							gps->totpoints = tot;
 
-					/* triangles cache needs to be recalculated */
-					gps->flag |= GP_STROKE_RECALC_CACHES;
-					gps->tot_triangles = 0;
+							/* triangles cache needs to be recalculated */
+							gps->flag |= GP_STROKE_RECALC_CACHES;
+							gps->tot_triangles = 0;
 
-					/* deselect the stroke, since none of its selected points will still be selected */
-					gps->flag &= ~GP_STROKE_SELECT;
-				}
+							/* deselect the stroke, since none of its selected points will still be selected */
+							gps->flag &= ~GP_STROKE_SELECT;
+							for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
+								pt->flag &= ~GP_SPOINT_SELECT;
+							}
+						}
 
-				changed = true;
+						changed = true;
+					}
+				}
 			}
 		}
 	}
 	CTX_DATA_END;
 
 	if (changed) {
+		DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 		WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 		return OPERATOR_FINISHED;
 	}
@@ -1146,17 +1729,17 @@ typedef struct tGPDeleteIsland {
  *      becomes much less
  * 2) Each island gets converted to a new stroke
  */
-void gp_stroke_delete_tagged_points(bGPDframe *gpf, bGPDstroke *gps, bGPDstroke *next_stroke, int tag_flags)
+void gp_stroke_delete_tagged_points(bGPDframe *gpf, bGPDstroke *gps, bGPDstroke *next_stroke,
+	int tag_flags, bool select)
 {
 	tGPDeleteIsland *islands = MEM_callocN(sizeof(tGPDeleteIsland) * (gps->totpoints + 1) / 2, "gp_point_islands");
 	bool in_island  = false;
 	int num_islands = 0;
 
-	bGPDspoint *pt;
-	int i;
 
 	/* First Pass: Identify start/end of islands */
-	for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
+	bGPDspoint *pt = gps->points;
+	for (int i = 0; i < gps->totpoints; i++, pt++) {
 		if (pt->flag & tag_flags) {
 			/* selected - stop accumulating to island */
 			in_island = false;
@@ -1198,11 +1781,26 @@ void gp_stroke_delete_tagged_points(bGPDframe *gpf, bGPDstroke *gps, bGPDstroke
 
 			/* Compute new buffer size (+ 1 needed as the endpoint index is "inclusive") */
 			new_stroke->totpoints = island->end_idx - island->start_idx + 1;
-			new_stroke->points    = MEM_callocN(sizeof(bGPDspoint) * new_stroke->totpoints, "gp delete stroke fragment");
 
-			/* Copy over the relevant points */
+			/* Copy over the relevant point data */
+			new_stroke->points    = MEM_callocN(sizeof(bGPDspoint) * new_stroke->totpoints, "gp delete stroke fragment");
 			memcpy(new_stroke->points, gps->points + island->start_idx, sizeof(bGPDspoint) * new_stroke->totpoints);
-
+			
+			/* Copy over vertex weight data (if available) */
+			if (new_stroke->dvert != NULL) {
+				/* Copy over the relevant vertex-weight points */
+				new_stroke->dvert     = MEM_callocN(sizeof(MDeformVert) * new_stroke->totpoints, "gp delete stroke fragment weight");
+				memcpy(new_stroke->dvert, gps->dvert + island->start_idx, sizeof(MDeformVert) * new_stroke->totpoints);
+				
+				/* Copy weights */
+				int e = island->start_idx;
+				for (int i = 0; i < new_stroke->totpoints; i++) {
+					MDeformVert *dvert_dst = &gps->dvert[e];
+					MDeformVert *dvert_src = &new_stroke->dvert[i];
+					dvert_dst->dw = MEM_dupallocN(dvert_src->dw);
+					e++;
+				}
+			}
 
 			/* Each island corresponds to a new stroke. We must adjust the
 			 * timings of these new strokes:
@@ -1222,6 +1820,11 @@ void gp_stroke_delete_tagged_points(bGPDframe *gpf, bGPDstroke *gps, bGPDstroke
 				pts = new_stroke->points;
 				for (j = 0; j < new_stroke->totpoints; j++, pts++) {
 					pts->time -= delta;
+					/* set flag for select again later */
+					if (select == true) {
+						pts->flag &= ~GP_SPOINT_SELECT;
+						pts->flag |= GP_SPOINT_TAG;
+					}
 				}
 			}
 
@@ -1239,53 +1842,70 @@ void gp_stroke_delete_tagged_points(bGPDframe *gpf, bGPDstroke *gps, bGPDstroke
 	MEM_freeN(islands);
 
 	/* Delete the old stroke */
-	MEM_freeN(gps->points);
+	if (gps->points) {
+		MEM_freeN(gps->points);
+	}
+	if (gps->dvert) {
+		BKE_gpencil_free_stroke_weights(gps);
+		MEM_freeN(gps->dvert);
+	}
 	if (gps->triangles) {
 		MEM_freeN(gps->triangles);
 	}
 	BLI_freelinkN(&gpf->strokes, gps);
 }
 
-
 /* Split selected strokes into segments, splitting on selected points */
 static int gp_delete_selected_points(bContext *C)
 {
+	Object *ob = CTX_data_active_object(C);
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
 	bool changed = false;
 
 	CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
 	{
-		bGPDframe *gpf = gpl->actframe;
-		bGPDstroke *gps, *gpsn;
+		bGPDframe *init_gpf = gpl->actframe;
+		if (is_multiedit) {
+			init_gpf = gpl->frames.first;
+		}
 
-		if (gpf == NULL)
-			continue;
+		for (bGPDframe *gpf = init_gpf; gpf; gpf = gpf->next) {
+			if ((gpf == gpl->actframe) || ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
+				bGPDstroke *gps, *gpsn;
 
-		/* simply delete strokes which are selected */
-		for (gps = gpf->strokes.first; gps; gps = gpsn) {
-			gpsn = gps->next;
+				if (gpf == NULL)
+					continue;
 
-			/* skip strokes that are invalid for current view */
-			if (ED_gpencil_stroke_can_use(C, gps) == false)
-				continue;
-			/* check if the color is editable */
-			if (ED_gpencil_stroke_color_use(gpl, gps) == false)
-				continue;
+				/* simply delete strokes which are selected */
+				for (gps = gpf->strokes.first; gps; gps = gpsn) {
+					gpsn = gps->next;
 
+					/* skip strokes that are invalid for current view */
+					if (ED_gpencil_stroke_can_use(C, gps) == false)
+						continue;
+					/* check if the color is editable */
+					if (ED_gpencil_stroke_color_use(ob, gpl, gps) == false)
+						continue;
 
-			if (gps->flag & GP_STROKE_SELECT) {
-				/* deselect old stroke, since it will be used as template for the new strokes */
-				gps->flag &= ~GP_STROKE_SELECT;
 
-				/* delete unwanted points by splitting stroke into several smaller ones */
-				gp_stroke_delete_tagged_points(gpf, gps, gpsn, GP_SPOINT_SELECT);
+					if (gps->flag & GP_STROKE_SELECT) {
+						/* deselect old stroke, since it will be used as template for the new strokes */
+						gps->flag &= ~GP_STROKE_SELECT;
 
-				changed = true;
+						/* delete unwanted points by splitting stroke into several smaller ones */
+						gp_stroke_delete_tagged_points(gpf, gps, gpsn, GP_SPOINT_SELECT, false);
+
+						changed = true;
+					}
+				}
 			}
 		}
 	}
 	CTX_DATA_END;
 
 	if (changed) {
+		DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 		WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 		return OPERATOR_FINISHED;
 	}
@@ -1294,6 +1914,12 @@ static int gp_delete_selected_points(bContext *C)
 	}
 }
 
+/* simple wrapper to external call */
+int gp_delete_selected_point_wrap(bContext *C)
+{
+	return gp_delete_selected_points(C);
+}
+
 /* ----------------------------------- */
 
 static int gp_delete_exec(bContext *C, wmOperator *op)
@@ -1344,24 +1970,37 @@ void GPENCIL_OT_delete(wmOperatorType *ot)
 	ot->prop = RNA_def_enum(ot->srna, "type", prop_gpencil_delete_types, 0, "Type", "Method used for deleting Grease Pencil data");
 }
 
-static int gp_dissolve_exec(bContext *C, wmOperator *UNUSED(op))
+static int gp_dissolve_exec(bContext *C, wmOperator *op)
 {
-	return gp_dissolve_selected_points(C);
+	eGP_DissolveMode mode = RNA_enum_get(op->ptr, "type");
+
+	return gp_dissolve_selected_points(C, mode);
 }
 
 void GPENCIL_OT_dissolve(wmOperatorType *ot)
 {
+	static EnumPropertyItem prop_gpencil_dissolve_types[] = {
+		{ GP_DISSOLVE_POINTS, "POINTS", 0, "Dissolve", "Dissolve selected points" },
+		{ GP_DISSOLVE_BETWEEN, "BETWEEN", 0, "Dissolve Between", "Dissolve points between selected points" },
+		{ GP_DISSOLVE_UNSELECT, "UNSELECT", 0, "Dissolve Unselect", "Dissolve all unselected points" },
+		{ 0, NULL, 0, NULL, NULL }
+	};
+
 	/* identifiers */
 	ot->name = "Dissolve";
 	ot->idname = "GPENCIL_OT_dissolve";
 	ot->description = "Delete selected points without splitting strokes";
 
 	/* callbacks */
+	ot->invoke = WM_menu_invoke;
 	ot->exec = gp_dissolve_exec;
 	ot->poll = gp_stroke_edit_poll;
 
 	/* flags */
 	ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER;
+
+	/* props */
+	ot->prop = RNA_def_enum(ot->srna, "type", prop_gpencil_dissolve_types, 0, "Type", "Method used for disolving Stroke points");
 }
 
 /* ****************** Snapping - Strokes <-> Cursor ************************ */
@@ -1384,6 +2023,8 @@ static int gp_snap_to_grid(bContext *C, wmOperator *UNUSED(op))
 {
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
 	RegionView3D *rv3d = CTX_wm_region_data(C);
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);                                      \
+	Object *obact = CTX_data_active_object(C);
 	const float gridf = rv3d->gridview;
 
 	for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
@@ -1392,10 +2033,8 @@ static int gp_snap_to_grid(bContext *C, wmOperator *UNUSED(op))
 			bGPDframe *gpf = gpl->actframe;
 			float diff_mat[4][4];
 
-			/* calculate difference matrix if parent object */
-			if (gpl->parent != NULL) {
-				ED_gpencil_parent_location(gpl, diff_mat);
-			}
+			/* calculate difference matrix object */
+			ED_gpencil_parent_location(depsgraph, obact, gpd, gpl, diff_mat);
 
 			for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
 				bGPDspoint *pt;
@@ -1405,37 +2044,32 @@ static int gp_snap_to_grid(bContext *C, wmOperator *UNUSED(op))
 				if (ED_gpencil_stroke_can_use(C, gps) == false)
 					continue;
 				/* check if the color is editable */
-				if (ED_gpencil_stroke_color_use(gpl, gps) == false)
+				if (ED_gpencil_stroke_color_use(obact, gpl, gps) == false)
 					continue;
 
 				// TODO: if entire stroke is selected, offset entire stroke by same amount?
 				for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
 					/* only if point is selected */
 					if (pt->flag & GP_SPOINT_SELECT) {
-						if (gpl->parent == NULL) {
-							pt->x = gridf * floorf(0.5f + pt->x / gridf);
-							pt->y = gridf * floorf(0.5f + pt->y / gridf);
-							pt->z = gridf * floorf(0.5f + pt->z / gridf);
-						}
-						else {
-							/* apply parent transformations */
-							float fpt[3];
-							mul_v3_m4v3(fpt, diff_mat, &pt->x);
+						/* apply parent transformations */
+						float fpt[3];
+						mul_v3_m4v3(fpt, diff_mat, &pt->x);
 
-							fpt[0] = gridf * floorf(0.5f + fpt[0] / gridf);
-							fpt[1] = gridf * floorf(0.5f + fpt[1] / gridf);
-							fpt[2] = gridf * floorf(0.5f + fpt[2] / gridf);
+						fpt[0] = gridf * floorf(0.5f + fpt[0] / gridf);
+						fpt[1] = gridf * floorf(0.5f + fpt[1] / gridf);
+						fpt[2] = gridf * floorf(0.5f + fpt[2] / gridf);
 
-							/* return data */
-							copy_v3_v3(&pt->x, fpt);
-							gp_apply_parent_point(gpl, pt);
-						}
+						/* return data */
+						copy_v3_v3(&pt->x, fpt);
+						gp_apply_parent_point(depsgraph, obact, gpd, gpl, pt);
 					}
 				}
 			}
 		}
 	}
 
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+	DEG_id_tag_update(&obact->id, DEG_TAG_COPY_ON_WRITE);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 	return OPERATOR_FINISHED;
 }
@@ -1463,6 +2097,8 @@ static int gp_snap_to_cursor(bContext *C, wmOperator *op)
 
 	Scene *scene = CTX_data_scene(C);
 	View3D *v3d = CTX_wm_view3d(C);
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);                                      \
+	Object *obact = CTX_data_active_object(C);                                          \
 
 	const bool use_offset = RNA_boolean_get(op->ptr, "use_offset");
 	const float *cursor_global = ED_view3d_cursor3d_get(scene, v3d)->location;
@@ -1473,10 +2109,8 @@ static int gp_snap_to_cursor(bContext *C, wmOperator *op)
 			bGPDframe *gpf = gpl->actframe;
 			float diff_mat[4][4];
 
-			/* calculate difference matrix if parent object */
-			if (gpl->parent != NULL) {
-				ED_gpencil_parent_location(gpl, diff_mat);
-			}
+			/* calculate difference matrix */
+			ED_gpencil_parent_location(depsgraph, obact, gpd, gpl, diff_mat);
 
 			for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
 				bGPDspoint *pt;
@@ -1486,7 +2120,7 @@ static int gp_snap_to_cursor(bContext *C, wmOperator *op)
 				if (ED_gpencil_stroke_can_use(C, gps) == false)
 					continue;
 				/* check if the color is editable */
-				if (ED_gpencil_stroke_color_use(gpl, gps) == false)
+				if (ED_gpencil_stroke_color_use(obact, gpl, gps) == false)
 					continue;
 				/* only continue if this stroke is selected (editable doesn't guarantee this)... */
 				if ((gps->flag & GP_STROKE_SELECT) == 0)
@@ -1509,9 +2143,7 @@ static int gp_snap_to_cursor(bContext *C, wmOperator *op)
 					for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
 						if (pt->flag & GP_SPOINT_SELECT) {
 							copy_v3_v3(&pt->x, cursor_global);
-							if (gpl->parent != NULL) {
-								gp_apply_parent_point(gpl, pt);
-							}
+							gp_apply_parent_point(depsgraph, obact, gpd, gpl, pt);
 						}
 					}
 				}
@@ -1520,6 +2152,8 @@ static int gp_snap_to_cursor(bContext *C, wmOperator *op)
 		}
 	}
 
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+    DEG_id_tag_update(&obact->id, DEG_TAG_COPY_ON_WRITE);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 	return OPERATOR_FINISHED;
 }
@@ -1551,6 +2185,8 @@ static int gp_snap_cursor_to_sel(bContext *C, wmOperator *UNUSED(op))
 
 	Scene *scene = CTX_data_scene(C);
 	View3D *v3d = CTX_wm_view3d(C);
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);                                      \
+	Object *obact = CTX_data_active_object(C);                                          \
 
 	float *cursor = ED_view3d_cursor3d_get(scene, v3d)->location;
 	float centroid[3] = {0.0f};
@@ -1566,10 +2202,8 @@ static int gp_snap_cursor_to_sel(bContext *C, wmOperator *UNUSED(op))
 			bGPDframe *gpf = gpl->actframe;
 			float diff_mat[4][4];
 
-			/* calculate difference matrix if parent object */
-			if (gpl->parent != NULL) {
-				ED_gpencil_parent_location(gpl, diff_mat);
-			}
+			/* calculate difference matrix */
+			ED_gpencil_parent_location(depsgraph, obact, gpd, gpl, diff_mat);
 
 			for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
 				bGPDspoint *pt;
@@ -1579,7 +2213,7 @@ static int gp_snap_cursor_to_sel(bContext *C, wmOperator *UNUSED(op))
 				if (ED_gpencil_stroke_can_use(C, gps) == false)
 					continue;
 				/* check if the color is editable */
-				if (ED_gpencil_stroke_color_use(gpl, gps) == false)
+				if (ED_gpencil_stroke_color_use(obact, gpl, gps) == false)
 					continue;
 				/* only continue if this stroke is selected (editable doesn't guarantee this)... */
 				if ((gps->flag & GP_STROKE_SELECT) == 0)
@@ -1587,18 +2221,13 @@ static int gp_snap_cursor_to_sel(bContext *C, wmOperator *UNUSED(op))
 
 				for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
 					if (pt->flag & GP_SPOINT_SELECT) {
-						if (gpl->parent == NULL) {
-							add_v3_v3(centroid, &pt->x);
-							minmax_v3v3_v3(min, max, &pt->x);
-						}
-						else {
-							/* apply parent transformations */
-							float fpt[3];
-							mul_v3_m4v3(fpt, diff_mat, &pt->x);
+						/* apply parent transformations */
+						float fpt[3];
+						mul_v3_m4v3(fpt, diff_mat, &pt->x);
 
 							add_v3_v3(centroid, fpt);
-							minmax_v3v3_v3(min, max, fpt);
-						}
+						minmax_v3v3_v3(min, max, fpt);
+
 						count++;
 					}
 				}
@@ -1616,7 +2245,9 @@ static int gp_snap_cursor_to_sel(bContext *C, wmOperator *UNUSED(op))
 	}
 
 
-	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+	DEG_id_tag_update(&scene->id, DEG_TAG_COPY_ON_WRITE);
+	WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, v3d);
+
 	return OPERATOR_FINISHED;
 }
 
@@ -1650,13 +2281,20 @@ static int gp_stroke_apply_thickness_exec(bContext *C, wmOperator *UNUSED(op))
 	for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
 		for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
 			/* Apply thickness */
-			gps->thickness = gps->thickness + gpl->thickness;
+			if ((gps->thickness == 0) && (gpl->line_change == 0)) {
+				gps->thickness = gpl->thickness;
+			}
+			else {
+				gps->thickness = gps->thickness + gpl->line_change;
+			}
 		}
 	}
 	/* clear value */
 	gpl->thickness = 0.0f;
+	gpl->line_change = 0;
 
 	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -1685,6 +2323,8 @@ enum {
 static int gp_stroke_cyclical_set_exec(bContext *C, wmOperator *op)
 {
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	Object *ob = CTX_data_active_object(C);
+
 	const int type = RNA_enum_get(op->ptr, "type");
 
 	/* sanity checks */
@@ -1698,13 +2338,13 @@ static int gp_stroke_cyclical_set_exec(bContext *C, wmOperator *op)
 			continue;
 
 		for (bGPDstroke *gps = gpl->actframe->strokes.last; gps; gps = gps->prev) {
-			bGPDpalettecolor *palcolor = gps->palcolor;
+			MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
 
 			/* skip strokes that are not selected or invalid for current view */
 			if (((gps->flag & GP_STROKE_SELECT) == 0) || ED_gpencil_stroke_can_use(C, gps) == false)
 				continue;
 			/* skip hidden or locked colors */
-			if (!palcolor || (palcolor->flag & PC_COLOR_HIDE) || (palcolor->flag & PC_COLOR_LOCKED))
+			if (!gp_style || (gp_style->flag & GP_STYLE_COLOR_HIDE) || (gp_style->flag & GP_STYLE_COLOR_LOCKED))
 				continue;
 
 			switch (type) {
@@ -1729,6 +2369,7 @@ static int gp_stroke_cyclical_set_exec(bContext *C, wmOperator *op)
 	CTX_DATA_END;
 
 	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -1809,15 +2450,24 @@ static void gpencil_flip_stroke(bGPDstroke *gps)
 }
 
 /* Helper: copy point between strokes */
-static void gpencil_stroke_copy_point(bGPDstroke *gps, bGPDspoint *point, float delta[3],
+static void gpencil_stroke_copy_point(bGPDstroke *gps, bGPDspoint *point, int idx, float delta[3],
                                       float pressure, float strength, float deltatime)
 {
 	bGPDspoint *newpoint;
+	MDeformVert *dvert, *newdvert;
 
 	gps->points = MEM_reallocN(gps->points, sizeof(bGPDspoint) * (gps->totpoints + 1));
+	if (gps->dvert != NULL) {
+		gps->dvert = MEM_reallocN(gps->dvert, sizeof(MDeformVert) * (gps->totpoints + 1));
+	}
 	gps->totpoints++;
-
 	newpoint = &gps->points[gps->totpoints - 1];
+
+	if (gps->dvert != NULL) {
+		dvert = &gps->dvert[idx];
+		newdvert = &gps->dvert[gps->totpoints - 1];
+	}
+
 	newpoint->x = point->x * delta[0];
 	newpoint->y = point->y * delta[1];
 	newpoint->z = point->z * delta[2];
@@ -1825,6 +2475,9 @@ static void gpencil_stroke_copy_point(bGPDstroke *gps, bGPDspoint *point, float
 	newpoint->pressure = pressure;
 	newpoint->strength = strength;
 	newpoint->time = point->time + deltatime;
+
+	newdvert->totweight = dvert->totweight;
+	newdvert->dw = MEM_dupallocN(dvert->dw);
 }
 
 /* Helper: join two strokes using the shortest distance (reorder stroke if necessary ) */
@@ -1870,18 +2523,18 @@ static void gpencil_stroke_join_strokes(bGPDstroke *gps_a, bGPDstroke *gps_b, co
 		/* 1st: add one tail point to start invisible area */
 		point = gps_a->points[gps_a->totpoints - 1];
 		deltatime = point.time;
-		gpencil_stroke_copy_point(gps_a, &point, delta, 0.0f, 0.0f, 0.0f);
+		gpencil_stroke_copy_point(gps_a, &point, gps_a->totpoints - 1, delta, 0.0f, 0.0f, 0.0f);
 
 		/* 2nd: add one head point to finish invisible area */
 		point = gps_b->points[0];
-		gpencil_stroke_copy_point(gps_a, &point, delta, 0.0f, 0.0f, deltatime);
+		gpencil_stroke_copy_point(gps_a, &point, 0, delta, 0.0f, 0.0f, deltatime);
 	}
 
 	/* 3rd: add all points */
 	for (i = 0, pt = gps_b->points; i < gps_b->totpoints && pt; i++, pt++) {
 		/* check if still room in buffer */
 		if (gps_a->totpoints <= GP_STROKE_BUFFER_MAX - 2) {
-			gpencil_stroke_copy_point(gps_a, pt, delta, pt->pressure, pt->strength, deltatime);
+			gpencil_stroke_copy_point(gps_a, pt, i, delta, pt->pressure, pt->strength, deltatime);
 		}
 	}
 }
@@ -1891,8 +2544,7 @@ static int gp_stroke_join_exec(bContext *C, wmOperator *op)
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
 	bGPDlayer *activegpl = BKE_gpencil_layer_getactive(gpd);
 	bGPDstroke *gps, *gpsn;
-	bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
-	bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
+	Object *ob = CTX_data_active_object(C);
 
 	bGPDframe *gpf_a = NULL;
 	bGPDstroke *stroke_a = NULL;
@@ -1928,7 +2580,7 @@ static int gp_stroke_join_exec(bContext *C, wmOperator *op)
 					continue;
 				}
 				/* check if the color is editable */
-				if (ED_gpencil_stroke_color_use(gpl, gps) == false) {
+				if (ED_gpencil_stroke_color_use(ob, gpl, gps) == false) {
 					continue;
 				}
 
@@ -1948,15 +2600,17 @@ static int gp_stroke_join_exec(bContext *C, wmOperator *op)
 					if (new_stroke == NULL) {
 						new_stroke = MEM_dupallocN(stroke_a);
 						new_stroke->points = MEM_dupallocN(stroke_a->points);
+						if (stroke_a->dvert != NULL) {
+							new_stroke->dvert = MEM_dupallocN(stroke_a->dvert);
+							BKE_gpencil_stroke_weights_duplicate(stroke_a, new_stroke);
+						}
 						new_stroke->triangles = NULL;
 						new_stroke->tot_triangles = 0;
 						new_stroke->flag |= GP_STROKE_RECALC_CACHES;
 
 						/* if new, set current color */
 						if (type == GP_STROKE_JOINCOPY) {
-							new_stroke->palcolor = palcolor;
-							BLI_strncpy(new_stroke->colorname, palcolor->info, sizeof(new_stroke->colorname));
-							new_stroke->flag |= GP_STROKE_RECALC_COLOR;
+							new_stroke->mat_nr = stroke_a->mat_nr;
 						}
 					}
 
@@ -1995,6 +2649,7 @@ static int gp_stroke_join_exec(bContext *C, wmOperator *op)
 	}
 
 	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -2030,6 +2685,7 @@ void GPENCIL_OT_stroke_join(wmOperatorType *ot)
 static int gp_stroke_flip_exec(bContext *C, wmOperator *UNUSED(op))
 {
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	Object *ob = CTX_data_active_object(C);
 
 	/* sanity checks */
 	if (ELEM(NULL, gpd))
@@ -2049,7 +2705,7 @@ static int gp_stroke_flip_exec(bContext *C, wmOperator *UNUSED(op))
 					continue;
 				}
 				/* check if the color is editable */
-				if (ED_gpencil_stroke_color_use(gpl, gps) == false) {
+				if (ED_gpencil_stroke_color_use(ob, gpl, gps) == false) {
 					continue;
 				}
 
@@ -2061,6 +2717,7 @@ static int gp_stroke_flip_exec(bContext *C, wmOperator *UNUSED(op))
 	CTX_DATA_END;
 
 	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -2084,33 +2741,42 @@ void GPENCIL_OT_stroke_flip(wmOperatorType *ot)
 /* ***************** Reproject Strokes ********************** */
 
 typedef enum eGP_ReprojectModes {
+	/* Axis (equal to lock axis) */
+	GP_REPROJECT_AXIS = 0,
 	/* On same plane, parallel to viewplane */
-	GP_REPROJECT_PLANAR = 0,
+	GP_REPROJECT_PLANAR,
 	/* Reprojected on to the scene geometry */
 	GP_REPROJECT_SURFACE,
 } eGP_ReprojectModes;
 
-static bool gp_strokes_reproject_poll(bContext *C)
-{
-	/* 2 Requirements:
-	 *  - 1) Editable GP data
-	 *  - 2) 3D View only (2D editors don't have projection issues)
-	 */
-	return (gp_stroke_edit_poll(C) && ED_operator_view3d_active(C));
-}
-
 static int gp_strokes_reproject_exec(bContext *C, wmOperator *op)
 {
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
 	Scene *scene = CTX_data_scene(C);
+	ToolSettings *ts = CTX_data_tool_settings(C);
+	Depsgraph *depsgraph = CTX_data_depsgraph(C);
+	Object *ob = CTX_data_active_object(C);
+	ScrArea *sa = CTX_wm_area(C);
+	ARegion *ar = CTX_wm_region(C);
+ 	RegionView3D *rv3d = ar->regiondata;
+	View3D *v3d = sa->spacedata.first;
+
 	GP_SpaceConversion gsc = {NULL};
-	eGP_ReprojectModes mode = RNA_boolean_get(op->ptr, "type");
+	eGP_ReprojectModes mode = RNA_enum_get(op->ptr, "type");
+
+	int lock_axis = ts->gp_sculpt.lock_axis;
+	float origin[3];
+
+	if ((mode == GP_REPROJECT_AXIS) && (lock_axis == GP_LOCKAXIS_NONE)) {
+		BKE_report(op->reports, RPT_ERROR, "To reproject by axis, a lock axis must be set before");
+		return OPERATOR_CANCELLED;
+	}
 
 	/* init space conversion stuff */
 	gp_point_conversion_init(C, &gsc);
 
 	/* init autodist for geometry projection */
 	if (mode == GP_REPROJECT_SURFACE) {
-		struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
 		view3d_region_operator_needs_opengl(CTX_wm_window(C), gsc.ar);
 		ED_view3d_autodist_init(depsgraph, gsc.ar, CTX_wm_view3d(C), 0);
 	}
@@ -2127,9 +2793,7 @@ static int gp_strokes_reproject_exec(bContext *C, wmOperator *op)
 
 			/* Compute inverse matrix for unapplying parenting once instead of doing per-point */
 			/* TODO: add this bit to the iteration macro? */
-			if (gpl->parent) {
-				invert_m4_m4(inverse_diff_mat, diff_mat);
-			}
+			invert_m4_m4(inverse_diff_mat, diff_mat);
 
 			/* Adjust each point */
 			for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
@@ -2140,19 +2804,28 @@ static int gp_strokes_reproject_exec(bContext *C, wmOperator *op)
 				 *       coordinates, resulting in lost precision, which in turn causes stairstepping
 				 *       artifacts in the final points.
 				 */
-				if (gpl->parent == NULL) {
-					gp_point_to_xy_fl(&gsc, gps, pt, &xy[0], &xy[1]);
-				}
-				else {
-					bGPDspoint pt2;
-					gp_point_to_parent_space(pt, diff_mat, &pt2);
-					gp_point_to_xy_fl(&gsc, gps, &pt2, &xy[0], &xy[1]);
+				bGPDspoint pt2;
+				gp_point_to_parent_space(pt, diff_mat, &pt2);
+				gp_point_to_xy_fl(&gsc, gps, &pt2, &xy[0], &xy[1]);
+
+				/* Project stroke in the axis locked */
+				if (mode == GP_REPROJECT_AXIS) {
+					if (lock_axis > GP_LOCKAXIS_NONE) {
+						ED_gp_get_drawing_reference(v3d, scene, ob, gpl,
+							ts->gpencil_v3d_align, origin);
+						ED_gp_project_point_to_plane(ob, rv3d, origin,
+							lock_axis - 1, &pt2);
+
+						copy_v3_v3(&pt->x, &pt2.x);
+
+						/* apply parent again */
+						gp_apply_parent_point(depsgraph, ob, gpd, gpl, pt);
+					}
 				}
-
 				/* Project screenspace back to 3D space (from current perspective)
 				 * so that all points have been treated the same way
 				 */
-				if (mode == GP_REPROJECT_PLANAR) {
+				else if (mode == GP_REPROJECT_PLANAR) {
 					/* Planar - All on same plane parallel to the viewplane */
 					gp_point_xy_to_3d(&gsc, scene, xy, &pt->x);
 				}
@@ -2175,7 +2848,7 @@ static int gp_strokes_reproject_exec(bContext *C, wmOperator *op)
 				}
 
 				/* Unapply parent corrections */
-				if (gpl->parent) {
+				if (mode != GP_REPROJECT_AXIS) {
 					mul_m4_v3(inverse_diff_mat, &pt->x);
 				}
 			}
@@ -2183,6 +2856,7 @@ static int gp_strokes_reproject_exec(bContext *C, wmOperator *op)
 	}
 	GP_EDITABLE_STROKES_END;
 
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 	return OPERATOR_FINISHED;
 }
@@ -2190,6 +2864,9 @@ static int gp_strokes_reproject_exec(bContext *C, wmOperator *op)
 void GPENCIL_OT_reproject(wmOperatorType *ot)
 {
 	static const EnumPropertyItem reproject_type[] = {
+		{ GP_REPROJECT_AXIS, "AXIS", 0, "Axis",
+		"Reproject the strokes using the current lock axis configuration. This is the same projection using while"
+		"drawing new strokes" },
 		{GP_REPROJECT_PLANAR, "PLANAR", 0, "Planar",
 		 "Reproject the strokes to end up on the same plane, as if drawn from the current viewpoint "
 		 "using 'Cursor' Stroke Placement"},
@@ -2208,7 +2885,7 @@ void GPENCIL_OT_reproject(wmOperatorType *ot)
 	/* callbacks */
 	ot->invoke = WM_menu_invoke;
 	ot->exec = gp_strokes_reproject_exec;
-	ot->poll = gp_strokes_reproject_poll;
+	ot->poll = gp_strokes_edit3d_poll;
 
 	/* flags */
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
@@ -2229,7 +2906,7 @@ static int gp_count_subdivision_cuts(bGPDstroke *gps)
 		if (pt->flag & GP_SPOINT_SELECT) {
 			if (i + 1 < gps->totpoints) {
 				if (gps->points[i + 1].flag & GP_SPOINT_SELECT) {
-					++totnewpoints;
+					totnewpoints++;
 				}
 			}
 		}
@@ -2237,6 +2914,7 @@ static int gp_count_subdivision_cuts(bGPDstroke *gps)
 
 	return totnewpoints;
 }
+
 static int gp_stroke_subdivide_exec(bContext *C, wmOperator *op)
 {
 	bGPdata *gpd = ED_gpencil_data_get_active(C);
@@ -2267,6 +2945,9 @@ static int gp_stroke_subdivide_exec(bContext *C, wmOperator *op)
 				/* resize the points arrys */
 				gps->totpoints += totnewpoints;
 				gps->points = MEM_recallocN(gps->points, sizeof(*gps->points) * gps->totpoints);
+				if (gps->dvert != NULL) {
+					gps->dvert = MEM_recallocN(gps->dvert, sizeof(*gps->dvert) * gps->totpoints);
+				}
 				gps->flag |= GP_STROKE_RECALC_CACHES;
 
 				/* loop and interpolate */
@@ -2275,19 +2956,27 @@ static int gp_stroke_subdivide_exec(bContext *C, wmOperator *op)
 					bGPDspoint *pt = &temp_points[i];
 					bGPDspoint *pt_final = &gps->points[i2];
 
+					MDeformVert *dvert_final = &gps->dvert[i2];
+
 					/* copy current point */
 					copy_v3_v3(&pt_final->x, &pt->x);
 					pt_final->pressure = pt->pressure;
 					pt_final->strength = pt->strength;
 					pt_final->time = pt->time;
 					pt_final->flag = pt->flag;
-					++i2;
+
+					dvert_final->totweight = 0;
+					dvert_final->dw = NULL;
+					i2++;
 
 					/* if next point is selected add a half way point */
 					if (pt->flag & GP_SPOINT_SELECT) {
 						if (i + 1 < oldtotpoints) {
 							if (temp_points[i + 1].flag & GP_SPOINT_SELECT) {
 								pt_final = &gps->points[i2];
+								if (gps->dvert != NULL) {
+									dvert_final = &gps->dvert[i2];
+								}
 								/* Interpolate all values */
 								bGPDspoint *next = &temp_points[i + 1];
 								interp_v3_v3v3(&pt_final->x, &pt->x, &next->x, 0.5f);
@@ -2296,7 +2985,11 @@ static int gp_stroke_subdivide_exec(bContext *C, wmOperator *op)
 								CLAMP(pt_final->strength, GPENCIL_STRENGTH_MIN, 1.0f);
 								pt_final->time = interpf(pt->time, next->time, 0.5f);
 								pt_final->flag |= GP_SPOINT_SELECT;
-								++i2;
+
+								dvert_final->totweight = 0;
+								dvert_final->dw = NULL;
+
+								i2++;
 							}
 						}
 					}
@@ -2309,6 +3002,7 @@ static int gp_stroke_subdivide_exec(bContext *C, wmOperator *op)
 	GP_EDITABLE_STROKES_END;
 
 	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 
 	return OPERATOR_FINISHED;
@@ -2328,7 +3022,7 @@ void GPENCIL_OT_stroke_subdivide(wmOperatorType *ot)
 	ot->poll = gp_active_layer_poll;
 
 	/* flags */
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
 	/* properties */
 	prop = RNA_def_int(ot->srna, "number_cuts", 1, 1, 10, "Number of Cuts", "", 1, 5);
@@ -2336,3 +3030,414 @@ void GPENCIL_OT_stroke_subdivide(wmOperatorType *ot)
 	RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 
 }
+
+/* ** simplify stroke *** */
+static int gp_stroke_simplify_exec(bContext *C, wmOperator *op)
+{
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	float factor = RNA_float_get(op->ptr, "factor");
+
+	/* sanity checks */
+	if (ELEM(NULL, gpd))
+		return OPERATOR_CANCELLED;
+
+	/* Go through each editable + selected stroke */
+	GP_EDITABLE_STROKES_BEGIN(C, gpl, gps)
+	{
+		if (gps->flag & GP_STROKE_SELECT) {
+			/* simplify stroke using Ramer-Douglas-Peucker algorithm */
+			BKE_gpencil_simplify_stroke(gps, factor);
+		}
+	}
+	GP_EDITABLE_STROKES_END;
+
+	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_stroke_simplify(wmOperatorType *ot)
+{
+	PropertyRNA *prop;
+
+	/* identifiers */
+	ot->name = "Simplify Stroke";
+	ot->idname = "GPENCIL_OT_stroke_simplify";
+	ot->description = "Simplify selected stroked reducing number of points";
+
+	/* api callbacks */
+	ot->exec = gp_stroke_simplify_exec;
+	ot->poll = gp_active_layer_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+	/* properties */
+	prop = RNA_def_float(ot->srna, "factor", 0.0f, 0.0f, 100.0f, "Factor", "", 0.0f, 100.0f);
+	/* avoid re-using last var */
+	RNA_def_property_flag(prop, PROP_SKIP_SAVE);
+}
+
+/* ** simplify stroke using fixed algorith *** */
+static int gp_stroke_simplify_fixed_exec(bContext *C, wmOperator *op)
+{
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	int steps = RNA_int_get(op->ptr, "step");
+
+	/* sanity checks */
+	if (ELEM(NULL, gpd))
+		return OPERATOR_CANCELLED;
+
+	/* Go through each editable + selected stroke */
+	GP_EDITABLE_STROKES_BEGIN(C, gpl, gps)
+	{
+		if (gps->flag & GP_STROKE_SELECT) {
+			for (int i = 0; i < steps; i++) {
+				BKE_gpencil_simplify_fixed(gps);
+			}
+		}
+	}
+	GP_EDITABLE_STROKES_END;
+
+	/* notifiers */
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_stroke_simplify_fixed(wmOperatorType *ot)
+{
+	PropertyRNA *prop;
+
+	/* identifiers */
+	ot->name = "Simplify Fixed Stroke";
+	ot->idname = "GPENCIL_OT_stroke_simplify_fixed";
+	ot->description = "Simplify selected stroked reducing number of points using fixed algorithm";
+
+	/* api callbacks */
+	ot->exec = gp_stroke_simplify_fixed_exec;
+	ot->poll = gp_active_layer_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+	/* properties */
+	prop = RNA_def_int(ot->srna, "step", 1, 1, 100, "Steps", "Number of simplify steps", 1, 10);
+
+	/* avoid re-using last var */
+	RNA_def_property_flag(prop, PROP_SKIP_SAVE);
+
+}
+
+/* ***************** Separate Strokes ********************** */
+typedef enum eGP_SeparateModes {
+	/* Points */
+	GP_SEPARATE_POINT = 0,
+	/* Selected Strokes */
+	GP_SEPARATE_STROKE,
+	/* Current Layer */
+	GP_SEPARATE_LAYER,
+} eGP_SeparateModes;
+
+static int gp_stroke_separate_exec(bContext *C, wmOperator *op)
+{
+	Base *base_new;
+	Main *bmain = CTX_data_main(C);
+	Scene *scene = CTX_data_scene(C);
+	ViewLayer *view_layer = CTX_data_view_layer(C);
+	Base *base_old = CTX_data_active_base(C);
+	bGPdata *gpd_src = ED_gpencil_data_get_active(C);
+	Object *ob = CTX_data_active_object(C);
+
+	Object *ob_dst = NULL;
+	bGPdata *gpd_dst = NULL;
+	bGPDlayer *gpl_dst = NULL;
+	bGPDframe *gpf_dst = NULL;
+	bGPDspoint *pt;
+	Material *ma = NULL;
+	int i, idx;
+
+	eGP_SeparateModes mode = RNA_enum_get(op->ptr, "mode");
+
+	/* sanity checks */
+	if (ELEM(NULL, gpd_src)) {
+		return OPERATOR_CANCELLED;
+	}
+	bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd_src);
+
+	/* create a new object */
+	base_new = ED_object_add_duplicate(bmain, scene, view_layer, base_old, 0);
+	ob_dst = base_new->object;
+
+	/* create new grease pencil datablock */
+	// XXX: check usercounts
+	gpd_dst = BKE_gpencil_data_addnew(bmain, "GPencil");
+	ob_dst->data = (bGPdata *)gpd_dst;
+
+	int totslots = ob_dst->totcol;
+	int totadd = 0;
+
+	/* loop old datablock and separate parts */
+	if ((mode == GP_SEPARATE_POINT) || (mode == GP_SEPARATE_STROKE)) {
+		CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
+		{
+			gpl_dst = NULL;
+			bGPDframe *init_gpf = gpl->actframe;
+			if (is_multiedit) {
+				init_gpf = gpl->frames.first;
+			}
+
+			for (bGPDframe *gpf = init_gpf; gpf; gpf = gpf->next) {
+				if ((gpf == gpl->actframe) || ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
+					bGPDstroke *gps, *gpsn;
+
+					if (gpf == NULL) {
+						continue;
+					}
+
+					gpf_dst = NULL;
+
+					for (gps = gpf->strokes.first; gps; gps = gpsn) {
+						gpsn = gps->next;
+
+						/* skip strokes that are invalid for current view */
+						if (ED_gpencil_stroke_can_use(C, gps) == false) {
+							continue;
+						}
+						/* check if the color is editable */
+						if (ED_gpencil_stroke_color_use(ob, gpl, gps) == false) {
+							continue;
+						}
+						/*  separate selected strokes */
+						if (gps->flag & GP_STROKE_SELECT) {
+							/* add layer if not created before */
+							if (gpl_dst == NULL) {
+								gpl_dst = BKE_gpencil_layer_addnew(gpd_dst, gpl->info, false);
+							}
+
+							/* add frame if not created before */
+							if (gpf_dst == NULL) {
+								gpf_dst = BKE_gpencil_layer_getframe(gpl_dst, gpf->framenum, GP_GETFRAME_ADD_NEW);
+							}
+
+							/* add duplicate materials */
+							ma = give_current_material(ob, gps->mat_nr + 1);
+							idx = BKE_object_material_slot_find_index(ob_dst, ma);
+							if (idx == 0) {
+
+								totadd++;
+								ob_dst->actcol = totadd;
+								ob_dst->totcol = totadd;
+
+								if (totadd > totslots) {
+									BKE_object_material_slot_add(bmain, ob_dst);
+								}
+
+								assign_material(bmain, ob_dst, ma, ob_dst->totcol, BKE_MAT_ASSIGN_EXISTING);
+								idx = totadd;
+							}
+
+							/* selected points mode */
+							if (mode == GP_SEPARATE_POINT) {
+								/* make copy of source stroke */
+								bGPDstroke *gps_dst = BKE_gpencil_stroke_duplicate(gps);
+
+								/* reasign material */
+								gps_dst->mat_nr = idx - 1;
+
+								/* link to destination frame */
+								BLI_addtail(&gpf_dst->strokes, gps_dst);
+
+								/* Invert selection status of all points in destination stroke */
+								for (i = 0, pt = gps_dst->points; i < gps_dst->totpoints; i++, pt++) {
+									pt->flag ^= GP_SPOINT_SELECT;
+								}
+
+								/* delete selected points from destination stroke */
+								gp_stroke_delete_tagged_points(gpf_dst, gps_dst, NULL, GP_SPOINT_SELECT, false);
+
+								/* delete selected points from origin stroke */
+								gp_stroke_delete_tagged_points(gpf, gps, gpsn, GP_SPOINT_SELECT, false);
+							}
+							/* selected strokes mode */
+							else if (mode == GP_SEPARATE_STROKE) {
+								/* deselect old stroke */
+								gps->flag &= ~GP_STROKE_SELECT;
+								/* unlink from source frame */
+								BLI_remlink(&gpf->strokes, gps);
+								gps->prev = gps->next = NULL;
+								/* relink to destination frame */
+								BLI_addtail(&gpf_dst->strokes, gps);
+								/* reasign material */
+								gps->mat_nr = idx - 1;
+							}
+						}
+					}
+				}
+
+				/* if not multiedit, exit loop*/
+				if (!is_multiedit) {
+					break;
+				}
+			}
+		}
+		CTX_DATA_END;
+	}
+	else if (mode == GP_SEPARATE_LAYER) {
+		bGPDlayer *gpl = CTX_data_active_gpencil_layer(C);
+		if (gpl) {
+			/* try to set a new active layer in source datablock */
+			if (gpl->prev) {
+				BKE_gpencil_layer_setactive(gpd_src, gpl->prev);
+			}
+			else if (gpl->next) {
+				BKE_gpencil_layer_setactive(gpd_src, gpl->next);
+			}
+			/* unlink from source datablock */
+			BLI_remlink(&gpd_src->layers, gpl);
+			gpl->prev = gpl->next = NULL;
+			/* relink to destination datablock */
+			BLI_addtail(&gpd_dst->layers, gpl);
+		}
+	}
+	DEG_id_tag_update(&gpd_src->id, OB_RECALC_OB | OB_RECALC_DATA);
+	DEG_id_tag_update(&gpd_dst->id, OB_RECALC_OB | OB_RECALC_DATA);
+
+	DEG_relations_tag_update(bmain);
+	WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, NULL);
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_stroke_separate(wmOperatorType *ot)
+{
+	static const EnumPropertyItem separate_type[] = {
+	{GP_SEPARATE_POINT, "POINT", 0, "Selected Points", "Separate the selected points" },
+	{GP_SEPARATE_STROKE, "STROKE", 0, "Selected Strokes", "Separate the selected strokes"},
+	{GP_SEPARATE_LAYER, "LAYER", 0, "Active Layer", "Separate the strokes of the current layer" },
+	{ 0, NULL, 0, NULL, NULL }
+	};
+
+	/* identifiers */
+	ot->name = "Separate Strokes";
+	ot->idname = "GPENCIL_OT_stroke_separate";
+	ot->description = "Separate the selected strokes or layer in a new grease pencil object";
+
+	/* callbacks */
+	ot->invoke = WM_menu_invoke;
+	ot->exec = gp_stroke_separate_exec;
+	ot->poll = gp_strokes_edit3d_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+	/* properties */
+	ot->prop = RNA_def_enum(ot->srna, "mode", separate_type, GP_SEPARATE_POINT, "Mode", "");
+}
+
+/* ***************** Split Strokes ********************** */
+static int gp_stroke_split_exec(bContext *C, wmOperator *UNUSED(op))
+{
+	Object *ob = CTX_data_active_object(C);
+	bGPdata *gpd = ED_gpencil_data_get_active(C);
+	bGPDspoint *pt;
+	int i;
+
+	/* sanity checks */
+	if (ELEM(NULL, gpd)) {
+		return OPERATOR_CANCELLED;
+	}
+	bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
+
+	/* loop strokes and split parts */
+	CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
+	{
+		bGPDframe *init_gpf = gpl->actframe;
+		if (is_multiedit) {
+			init_gpf = gpl->frames.first;
+		}
+
+		for (bGPDframe *gpf = init_gpf; gpf; gpf = gpf->next) {
+			if ((gpf == gpl->actframe) || ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
+				bGPDstroke *gps, *gpsn;
+
+				if (gpf == NULL) {
+					continue;
+				}
+
+				for (gps = gpf->strokes.first; gps; gps = gpsn) {
+					gpsn = gps->next;
+
+					/* skip strokes that are invalid for current view */
+					if (ED_gpencil_stroke_can_use(C, gps) == false) {
+						continue;
+					}
+					/* check if the color is editable */
+					if (ED_gpencil_stroke_color_use(ob, gpl, gps) == false) {
+						continue;
+					}
+					/*  split selected strokes */
+					if (gps->flag & GP_STROKE_SELECT) {
+						/* make copy of source stroke */
+						bGPDstroke *gps_dst = BKE_gpencil_stroke_duplicate(gps);
+
+						/* link to same frame */
+						BLI_addtail(&gpf->strokes, gps_dst);
+
+						/* invert selection status of all points in destination stroke */
+						for (i = 0, pt = gps_dst->points; i < gps_dst->totpoints; i++, pt++) {
+							pt->flag ^= GP_SPOINT_SELECT;
+						}
+
+						/* delete selected points from destination stroke */
+						gp_stroke_delete_tagged_points(gpf, gps_dst, NULL, GP_SPOINT_SELECT, true);
+
+						/* delete selected points from origin stroke */
+						gp_stroke_delete_tagged_points(gpf, gps, gpsn, GP_SPOINT_SELECT, false);
+					}
+				}
+				/* select again tagged points */
+				for (gps = gpf->strokes.first; gps; gps = gps->next) {
+					bGPDspoint *ptn = gps->points;
+					for (int i2 = 0; i2 < gps->totpoints; i2++, ptn++) {
+						if (ptn->flag & GP_SPOINT_TAG) {
+							ptn->flag |= GP_SPOINT_SELECT;
+							ptn->flag &= ~GP_SPOINT_TAG;
+						}
+					}
+				}
+			}
+
+			/* if not multiedit, exit loop*/
+			if (!is_multiedit) {
+				break;
+			}
+		}
+	}
+	CTX_DATA_END;
+
+	DEG_id_tag_update(&gpd->id, OB_RECALC_OB | OB_RECALC_DATA);
+
+	WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+void GPENCIL_OT_stroke_split(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Split Strokes";
+	ot->idname = "GPENCIL_OT_stroke_split";
+	ot->description = "Split selected points as new stroke on same frame";
+
+	/* callbacks */
+	ot->exec = gp_stroke_split_exec;
+	ot->poll = gp_strokes_edit3d_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}