Grease Pencil v2 Branch

Improve current Grease Pencil in order to get a better 2D animation tool.

More info in WIKI pages: https://wiki.blender.org/index.php/User:Antoniov

Reviewed By: Severin, aligorith, campbellbarton

Patch by @antoniov, with edits by @Severin.

Differential Revision: https://developer.blender.org/D2115

1 files changed, 721 insertions, 80 deletions

diff --git a/source/blender/makesrna/intern/rna_gpencil.c b/source/blender/makesrna/intern/rna_gpencil.c
index 52c04bec743..619eecad8e5 100644
--- a/source/blender/makesrna/intern/rna_gpencil.c
+++ b/source/blender/makesrna/intern/rna_gpencil.c
@@ -15,7 +15,7 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
- * Contributor(s): Blender Foundation (2009), Joshua Leung
+ * Contributor(s): Blender Foundation (2009), Joshua Leung, Antonio Vazquez
  *
  * ***** END GPL LICENSE BLOCK *****
  */
@@ -41,6 +41,17 @@
 #include "rna_internal.h"
 
 #include "WM_types.h"
+#include "DNA_object_types.h"
+#include "ED_gpencil.h"
+
+/* parent type */
+static EnumPropertyItem parent_type_items[] = {
+	{PAROBJECT, "OBJECT", 0, "Object", "The layer is parented to an object"},
+	{PARSKEL, "ARMATURE", 0, "Armature", ""},
+	{PARBONE, "BONE", 0, "Bone", "The layer is parented to a bone"},
+	{0, NULL, 0, NULL, NULL}
+};
+
 
 #ifdef RNA_RUNTIME
 
@@ -49,8 +60,7 @@
 #include "WM_api.h"
 
 #include "BKE_gpencil.h"
-
-#include "DNA_object_types.h"
+#include "BKE_action.h"
 
 
 static void rna_GPencil_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *UNUSED(ptr))
@@ -90,6 +100,16 @@ static void rna_GPencil_onion_skinning_update(Main *bmain, Scene *scene, Pointer
 	rna_GPencil_update(bmain, scene, ptr);
 }
 
+static void rna_GPencil_stroke_colorname_update(Main *bmain, Scene *scene, PointerRNA *ptr)
+{
+	bGPDstroke *gps = (bGPDstroke *)ptr->data;
+	gps->flag |= GP_STROKE_RECALC_COLOR;
+	gps->palcolor = NULL;
+
+	/* Now do standard updates... */
+	rna_GPencil_update(bmain, scene, ptr);
+}
+
 static char *rna_GPencilLayer_path(PointerRNA *ptr)
 {
 	bGPDlayer *gpl = (bGPDlayer *)ptr->data;
@@ -123,38 +143,140 @@ static void rna_GPencilLayer_line_width_range(PointerRNA *ptr, int *min, int *ma
 	 * it's relatively hard to test for that. So, for now, only volumetric strokes
 	 * get to be larger...
 	 */
+
+	/* From GP v2 this value is used to increase or decrease the thickness of the stroke */
 	if (gpl->flag & GP_LAYER_VOLUMETRIC) {
-		*min = 1;
+		*min = -300;
 		*max = 300;
 		
-		*softmin = 1;
+		*softmin = -100;
 		*softmax = 100;
 	}
 	else {
-		*min = 1;
+		*min = -10;
 		*max = 10;
 		
-		*softmin = 1;
+		*softmin = -10;
 		*softmax = 10;
 	}
 }
 
-static int rna_GPencilLayer_is_stroke_visible_get(PointerRNA *ptr)
+/* set parent */
+static void set_parent(bGPDlayer *gpl, Object *par, const int type, const char *substr)
+{
+	if (type == PAROBJECT) {
+		invert_m4_m4(gpl->inverse, par->obmat);
+		gpl->parent = par;
+		gpl->partype |= PAROBJECT;
+		gpl->parsubstr[0] = 0;
+	}
+	else if (type == PARSKEL) {
+		invert_m4_m4(gpl->inverse, par->obmat);
+		gpl->parent = par;
+		gpl->partype |= PARSKEL;
+		gpl->parsubstr[0] = 0;
+	}
+	else if (type == PARBONE) {
+		bPoseChannel *pchan = BKE_pose_channel_find_name(par->pose, substr);
+		if (pchan) {
+			float tmp_mat[4][4];
+			mul_m4_m4m4(tmp_mat, par->obmat, pchan->pose_mat);
+
+			invert_m4_m4(gpl->inverse, tmp_mat);
+			gpl->parent = par;
+			gpl->partype |= PARBONE;
+			BLI_strncpy(gpl->parsubstr, substr, sizeof(gpl->parsubstr));
+		}
+	}
+}
+
+/* set parent object and inverse matrix */
+static void rna_GPencilLayer_parent_set(PointerRNA *ptr, PointerRNA value)
 {
-	/* see drawgpencil.c -> gp_draw_data_layers() for more details
-	 * about this limit for showing/not showing
-	 */
 	bGPDlayer *gpl = (bGPDlayer *)ptr->data;
-	return (gpl->color[3] > GPENCIL_ALPHA_OPACITY_THRESH);
+	Object *par = (Object *)value.data; 
+
+	if (par != NULL) {
+		set_parent(gpl, par, gpl->partype, gpl->parsubstr);
+	}
+	else {
+		/* keep strokes in the same place, so apply current transformation */
+		if (gpl->parent != NULL) {
+			bGPDspoint *pt;
+			int i;
+			float diff_mat[4][4];
+			/* calculate difference matrix */
+			ED_gpencil_parent_location(gpl, diff_mat);
+			for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
+				for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
+					for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
+						mul_m4_v3(diff_mat, &pt->x);
+					}
+				}
+			}
+		}
+		/* clear parent */
+		gpl->parent = NULL;
+	}
 }
 
-static int rna_GPencilLayer_is_fill_visible_get(PointerRNA *ptr)
+/* set parent type */
+static void rna_GPencilLayer_parent_type_set(PointerRNA *ptr, int value)
+{
+	bGPDlayer *gpl = (bGPDlayer *)ptr->data;
+	Object *par = gpl->parent;
+	gpl->partype = value;
+
+	if (par != NULL) {
+		set_parent(gpl, par, value, gpl->parsubstr);
+	}
+}
+
+/* set parent bone */
+static void rna_GPencilLayer_parent_bone_set(PointerRNA *ptr, const char *value)
+{
+	bGPDlayer *gpl = (bGPDlayer *)ptr->data;
+
+	Object *par = gpl->parent;
+	gpl->partype = PARBONE;
+
+	if (par != NULL) {
+		set_parent(gpl, par, gpl->partype, value);
+	}
+}
+
+
+/* parent types enum */
+static EnumPropertyItem *rna_Object_parent_type_itemf(
+        bContext *UNUSED(C), PointerRNA *ptr,
+        PropertyRNA *UNUSED(prop), bool *r_free)
+{
+	bGPDlayer *gpl = (bGPDlayer *)ptr->data;
+	EnumPropertyItem *item = NULL;
+	int totitem = 0;
+
+	RNA_enum_items_add_value(&item, &totitem, parent_type_items, PAROBJECT);
+
+	if (gpl->parent) {
+		Object *par = gpl->parent;
+
+		if (par->type == OB_ARMATURE) {
+			/* special hack: prevents this being overrided */
+			RNA_enum_items_add_value(&item, &totitem, &parent_type_items[1], PARSKEL);
+			RNA_enum_items_add_value(&item, &totitem, parent_type_items, PARBONE);
+		}
+	}
+
+	RNA_enum_item_end(&item, &totitem);
+	*r_free = true;
+
+	return item;
+}
+
+static int rna_GPencilLayer_is_parented_get(PointerRNA *ptr)
 {
-	/* see drawgpencil.c -> gp_draw_data_layers() for more details
-	 * about this limit for showing/not showing
-	 */
 	bGPDlayer *gpl = (bGPDlayer *)ptr->data;
-	return (gpl->fill[3] > GPENCIL_ALPHA_OPACITY_THRESH);
+	return (gpl->parent != NULL);
 }
 
 static PointerRNA rna_GPencil_active_layer_get(PointerRNA *ptr)
@@ -357,10 +479,12 @@ static void rna_GPencil_stroke_point_pop(bGPDstroke *stroke, ReportList *reports
 	WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
 }
 
-static bGPDstroke *rna_GPencil_stroke_new(bGPDframe *frame)
+static bGPDstroke *rna_GPencil_stroke_new(bGPDframe *frame, const char *colorname)
 {
 	bGPDstroke *stroke = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
-
+	strcpy(stroke->colorname, colorname);
+	stroke->palcolor = NULL;
+	stroke->flag |= GP_STROKE_RECALC_COLOR;
 	BLI_addtail(&frame->strokes, stroke);
 
 	return stroke;
@@ -490,6 +614,239 @@ static void rna_GPencil_clear(bGPdata *gpd)
 	WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
 }
 
+/* Palettes */
+static bGPDpalette *rna_GPencil_palette_new(bGPdata *gpd, const char *name, int setactive)
+{
+	bGPDpalette *palette = gpencil_palette_addnew(gpd, name, setactive != 0);
+
+	WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+
+	return palette;
+}
+
+static void rna_GPencil_palette_remove(bGPdata *gpd, ReportList *reports, PointerRNA *palette_ptr)
+{
+	bGPDpalette *palette = palette_ptr->data;
+	if (BLI_findindex(&gpd->palettes, palette) == -1) {
+		BKE_report(reports, RPT_ERROR, "Palette not found in grease pencil data");
+		return;
+	}
+
+	gpencil_palette_delete(gpd, palette);
+	RNA_POINTER_INVALIDATE(palette_ptr);
+
+	WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+}
+
+static PointerRNA rna_GPencil_active_palette_get(PointerRNA *ptr)
+{
+	bGPdata *gpd = ptr->id.data;
+
+	if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
+		bGPDpalette *palette;
+
+		for (palette = gpd->palettes.first; palette; palette = palette->next) {
+			if (palette->flag & PL_PALETTE_ACTIVE) {
+				break;
+			}
+		}
+
+		if (palette) {
+			return rna_pointer_inherit_refine(ptr, &RNA_GPencilPalette, palette);
+		}
+	}
+
+	return rna_pointer_inherit_refine(ptr, NULL, NULL);
+}
+
+static void rna_GPencil_active_palette_set(PointerRNA *ptr, PointerRNA value)
+{
+	bGPdata *gpd = ptr->id.data;
+
+	if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
+		bGPDpalette *palette;
+
+		for (palette = gpd->palettes.first; palette; palette = palette->next) {
+			if (palette == value.data) {
+				palette->flag |= PL_PALETTE_ACTIVE;
+			}
+			else {
+				palette->flag &= ~PL_PALETTE_ACTIVE;
+			}
+		}
+		/* force color recalc */
+		gpencil_palette_change_strokes(gpd);
+
+		WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
+	}
+}
+
+static int rna_GPencilPalette_index_get(PointerRNA *ptr)
+{
+	bGPdata *gpd = (bGPdata *)ptr->id.data;
+	bGPDpalette *palette = gpencil_palette_getactive(gpd);
+
+	return BLI_findindex(&gpd->palettes, palette);
+}
+
+static void rna_GPencilPalette_index_set(PointerRNA *ptr, int value)
+{
+	bGPdata *gpd   = (bGPdata *)ptr->id.data;
+	bGPDpalette *palette = BLI_findlink(&gpd->palettes, value);
+
+	gpencil_palette_setactive(gpd, palette);
+	WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+}
+
+static void rna_GPencilPalette_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
+{
+	bGPdata *gpd = (bGPdata *)ptr->id.data;
+
+	*min = 0;
+	*max = max_ii(0, BLI_listbase_count(&gpd->palettes) - 1);
+
+	*softmin = *min;
+	*softmax = *max;
+}
+
+/* Palette colors */
+static bGPDpalettecolor *rna_GPencilPalette_color_new(bGPDpalette *palette)
+{
+	bGPDpalettecolor *color = gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
+
+	return color;
+}
+
+static void rna_GPencilPalette_color_remove(bGPDpalette *palette, ReportList *reports, PointerRNA *color_ptr)
+{
+	bGPDpalettecolor *color = color_ptr->data;
+
+	if (BLI_findindex(&palette->colors, color) == -1) {
+		BKE_reportf(reports, RPT_ERROR, "Palette '%s' does not contain color given", palette->info + 2);
+		return;
+	}
+
+	gpencil_palettecolor_delete(palette, color);
+	RNA_POINTER_INVALIDATE(color_ptr);
+
+	WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
+}
+
+static PointerRNA rna_GPencilPalette_active_color_get(PointerRNA *ptr)
+{
+	bGPDpalette *palette = (bGPDpalette *)ptr->data;
+	bGPDpalettecolor *color;
+
+	for (color = palette->colors.first; color; color = color->next) {
+		if (color->flag & PC_COLOR_ACTIVE) {
+			break;
+		}
+	}
+
+	if (color) {
+		return rna_pointer_inherit_refine(ptr, &RNA_GPencilPaletteColor, color);
+	}
+
+	return rna_pointer_inherit_refine(ptr, NULL, NULL);
+}
+
+static void rna_GPencilPalette_active_color_set(PointerRNA *ptr, PointerRNA value)
+{
+	bGPDpalette *palette = (bGPDpalette *)ptr->data;
+	bGPDpalettecolor *color = value.data;
+
+	gpencil_palettecolor_setactive(palette, color);
+}
+
+static void rna_GPencilPalette_info_set(PointerRNA *ptr, const char *value)
+{
+	bGPdata *gpd = ptr->id.data;
+	bGPDpalette *palette = ptr->data;
+
+	/* copy the new name into the name slot */
+	BLI_strncpy_utf8(palette->info, value, sizeof(palette->info));
+
+	BLI_uniquename(&gpd->palettes, palette, DATA_("GP_Palette"), '.', offsetof(bGPDpalette, info),
+	               sizeof(palette->info));
+}
+
+static char *rna_GPencilPalette_color_path(PointerRNA *ptr)
+{
+	bGPdata *gpd = ptr->id.data;
+	bGPDpalette *palette = gpencil_palette_getactive(gpd);
+	bGPDpalettecolor *palcolor = ptr->data;
+
+	char name_palette[sizeof(palette->info) * 2];
+	char name_color[sizeof(palcolor->info) * 2];
+
+	BLI_strescape(name_palette, palette->info, sizeof(name_palette));
+	BLI_strescape(name_color, palcolor->info, sizeof(name_color));
+
+	return BLI_sprintfN("palettes[\"%s\"].colors[\"%s\"]", name_palette, name_color);
+}
+
+static void rna_GPencilPaletteColor_info_set(PointerRNA *ptr, const char *value)
+{
+	bGPdata *gpd = ptr->id.data;
+	bGPDpalette *palette = gpencil_palette_getactive(gpd);
+	bGPDpalettecolor *palcolor = ptr->data;
+
+	/* rename all strokes */
+	gpencil_palettecolor_changename(gpd, palcolor->info, value);
+
+	/* copy the new name into the name slot */
+	BLI_strncpy_utf8(palcolor->info, value, sizeof(palcolor->info));
+	BLI_uniquename(&palette->colors, palcolor, DATA_("Color"), '.', offsetof(bGPDpalettecolor, info),
+	               sizeof(palcolor->info));
+}
+
+static void rna_GPencilStrokeColor_info_set(PointerRNA *ptr, const char *value)
+{
+	bGPDstroke *gps = ptr->data;
+
+	/* copy the new name into the name slot */
+	BLI_strncpy_utf8(gps->colorname, value, sizeof(gps->colorname));
+}
+
+
+static int rna_GPencilPaletteColor_is_stroke_visible_get(PointerRNA *ptr)
+{
+	bGPDpalettecolor *pcolor = (bGPDpalettecolor *)ptr->data;
+	return (pcolor->color[3] > GPENCIL_ALPHA_OPACITY_THRESH);
+}
+
+static int rna_GPencilPaletteColor_is_fill_visible_get(PointerRNA *ptr)
+{
+	bGPDpalettecolor *pcolor = (bGPDpalettecolor *)ptr->data;
+	return (pcolor->fill[3] > GPENCIL_ALPHA_OPACITY_THRESH);
+}
+
+static int rna_GPencilPaletteColor_index_get(PointerRNA *ptr)
+{
+	bGPDpalette *palette = (bGPDpalette *)ptr->data;
+	bGPDpalettecolor *pcolor = gpencil_palettecolor_getactive(palette);
+
+	return BLI_findindex(&palette->colors, pcolor);
+}
+
+static void rna_GPencilPaletteColor_index_set(PointerRNA *ptr, int value)
+{
+	bGPDpalette *palette = (bGPDpalette *)ptr->data;
+	bGPDpalettecolor *pcolor = BLI_findlink(&palette->colors, value);
+	gpencil_palettecolor_setactive(palette, pcolor);
+}
+
+static void rna_GPencilPaletteColor_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
+{
+	bGPDpalette *palette = (bGPDpalette *)ptr->data;
+
+	*min = 0;
+	*max = max_ii(0, BLI_listbase_count(&palette->colors) - 1);
+
+	*softmin = *min;
+	*softmax = *max;
+}
+
 #else
 
 static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
@@ -513,6 +870,12 @@ static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Pressure", "Pressure of tablet at point when drawing it");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 	
+	prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "strength");
+	RNA_def_property_range(prop, 0.0f, 1.0f);
+	RNA_def_property_ui_text(prop, "Strength", "Color intensity (alpha factor)");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
 	prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SPOINT_SELECT);
 	RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_point_select_set");
@@ -542,6 +905,35 @@ static void rna_def_gpencil_stroke_points_api(BlenderRNA *brna, PropertyRNA *cpr
 	RNA_def_int(func, "index", -1, INT_MIN, INT_MAX, "Index", "point index", INT_MIN, INT_MAX);
 }
 
+/* This information is read only and it can be used by add-ons */
+static void rna_def_gpencil_triangle(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	srna = RNA_def_struct(brna, "GPencilTriangle", NULL);
+	RNA_def_struct_sdna(srna, "bGPDtriangle");
+	RNA_def_struct_ui_text(srna, "Triangle", "Triangulation data for HQ fill");
+
+	/* point v1 */
+	prop = RNA_def_property(srna, "v1", PROP_INT, PROP_NONE);
+	RNA_def_property_int_sdna(prop, NULL, "v1");
+	RNA_def_property_ui_text(prop, "v1", "First triangle vertice index");
+	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
+	/* point v2 */
+	prop = RNA_def_property(srna, "v2", PROP_INT, PROP_NONE);
+	RNA_def_property_int_sdna(prop, NULL, "v2");
+	RNA_def_property_ui_text(prop, "v2", "Second triangle vertice index");
+	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
+	/* point v3 */
+	prop = RNA_def_property(srna, "v3", PROP_INT, PROP_NONE);
+	RNA_def_property_int_sdna(prop, NULL, "v3");
+	RNA_def_property_ui_text(prop, "v3", "Third triangle vertice index");
+	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+}
+
 static void rna_def_gpencil_stroke(BlenderRNA *brna)
 {
 	StructRNA *srna;
@@ -566,6 +958,19 @@ static void rna_def_gpencil_stroke(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
 	rna_def_gpencil_stroke_points_api(brna, prop);
 	
+	/* Triangles */
+	prop = RNA_def_property(srna, "triangles", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "triangles", "tot_triangles");
+	RNA_def_property_struct_type(prop, "GPencilTriangle");
+	RNA_def_property_ui_text(prop, "Triangles", "Triangulation data for HQ fill");
+
+	/* Color */
+	prop = RNA_def_property(srna, "color", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "GPencilPaletteColor");
+	RNA_def_property_pointer_sdna(prop, NULL, "palcolor");
+	RNA_def_property_ui_text(prop, "Palette Color", "Color from palette used in Stroke");
+	RNA_def_property_update(prop, 0, "rna_GPencil_update");
+
 	/* Settings */
 	prop = RNA_def_property(srna, "draw_mode", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
@@ -578,6 +983,27 @@ static void rna_def_gpencil_stroke(BlenderRNA *brna)
 	RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_select_set");
 	RNA_def_property_ui_text(prop, "Select", "Stroke is selected for viewport editing");
 	RNA_def_property_update(prop, 0, "rna_GPencil_update");
+
+	/* Color Name */
+	prop = RNA_def_property(srna, "colorname", PROP_STRING, PROP_NONE);
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilStrokeColor_info_set");
+	RNA_def_property_ui_text(prop, "Color Name", "Palette color name");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_stroke_colorname_update");
+
+	/* Cyclic: Draw a line from end to start point */
+	prop = RNA_def_property(srna, "draw_cyclic", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_CYCLIC);
+	RNA_def_property_ui_text(prop, "Cyclic", "Enable cyclic drawing, closing the stroke");
+	RNA_def_property_update(prop, 0, "rna_GPencil_update");
+
+	/* Line Thickness */
+	prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
+	RNA_def_property_int_sdna(prop, NULL, "thickness");
+	RNA_def_property_range(prop, 1, 300);
+	RNA_def_property_ui_range(prop, 1, 10, 1, 0);
+	RNA_def_property_ui_text(prop, "Thickness", "Thickness of stroke (in pixels)");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
 }
 
 static void rna_def_gpencil_strokes_api(BlenderRNA *brna, PropertyRNA *cprop)
@@ -594,6 +1020,7 @@ static void rna_def_gpencil_strokes_api(BlenderRNA *brna, PropertyRNA *cprop)
 
 	func = RNA_def_function(srna, "new", "rna_GPencil_stroke_new");
 	RNA_def_function_ui_description(func, "Add a new grease pencil stroke");
+	parm = RNA_def_string(func, "colorname", 0, MAX_NAME, "Color", "Name of the color");
 	parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "", "The newly created stroke");
 	RNA_def_function_return(func, parm);
 
@@ -721,45 +1148,33 @@ static void rna_def_gpencil_layer(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Volumetric Strokes", "Draw strokes as a series of circular blobs, resulting in a volumetric effect");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 	
-	/* Use High Quality Fill */
-	prop = RNA_def_property(srna, "use_hq_fill", PROP_BOOLEAN, PROP_NONE);
-	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HQ_FILL);
-	RNA_def_property_ui_text(prop, "High Quality Fill", "Fill strokes using high quality method to avoid glitches (slower fps during animation playback)");
-	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
-
-	/* Stroke Drawing Color */
-	prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
-	RNA_def_property_array(prop, 3);
-	RNA_def_property_range(prop, 0.0f, 1.0f);
-	RNA_def_property_ui_text(prop, "Color", "Color for all strokes in this layer");
-	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
-	
-	prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
-	RNA_def_property_float_sdna(prop, NULL, "color[3]");
+	prop = RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "opacity");
 	RNA_def_property_range(prop, 0.0, 1.0f);
 	RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 	
-	/* Fill Drawing Color */
-	prop = RNA_def_property(srna, "fill_color", PROP_FLOAT, PROP_COLOR_GAMMA);
-	RNA_def_property_float_sdna(prop, NULL, "fill");
+	/* Tint Color */
+	prop = RNA_def_property(srna, "tint_color", PROP_FLOAT, PROP_COLOR_GAMMA);
+	RNA_def_property_float_sdna(prop, NULL, "tintcolor");
 	RNA_def_property_array(prop, 3);
 	RNA_def_property_range(prop, 0.0f, 1.0f);
-	RNA_def_property_ui_text(prop, "Fill Color", "Color for filling region bounded by each stroke");
+	RNA_def_property_ui_text(prop, "Tint Color", "Color for tinting stroke colors");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 	
-	prop = RNA_def_property(srna, "fill_alpha", PROP_FLOAT, PROP_NONE);
-	RNA_def_property_float_sdna(prop, NULL, "fill[3]");
+	/* Tint factor */
+	prop = RNA_def_property(srna, "tint_factor", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "tintcolor[3]");
 	RNA_def_property_range(prop, 0.0, 1.0f);
-	RNA_def_property_ui_text(prop, "Fill Opacity", "Opacity for filling region bounded by each stroke");
+	RNA_def_property_ui_text(prop, "Tint Factor", "Factor of tinting color");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 	
-	/* Line Thickness */
-	prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
+	/* Line Thickness change */
+	prop = RNA_def_property(srna, "line_change", PROP_INT, PROP_PIXEL);
 	RNA_def_property_int_sdna(prop, NULL, "thickness");
 	//RNA_def_property_range(prop, 1, 10); /* 10 px limit comes from Windows OpenGL limits for natively-drawn strokes */
 	RNA_def_property_int_funcs(prop, NULL, NULL, "rna_GPencilLayer_line_width_range");
-	RNA_def_property_ui_text(prop, "Thickness", "Thickness of strokes (in pixels)");
+	RNA_def_property_ui_text(prop, "Thickness", "Thickness change to apply current strokes (in pixels)");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 	
 	/* Onion-Skinning */
@@ -803,31 +1218,6 @@ static void rna_def_gpencil_layer(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 	
-	/* Smoothing factor for new strokes */
-	prop = RNA_def_property(srna, "pen_smooth_factor", PROP_FLOAT, PROP_NONE);
-	RNA_def_property_float_sdna(prop, NULL, "draw_smoothfac");
-	RNA_def_property_range(prop, 0.0, 2.0f);
-	RNA_def_property_ui_text(prop, "Smooth",
-	                         "Amount of smoothing to apply to newly created strokes, to reduce jitter/noise");
-	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
-	
-	/* Iterations of the Smoothing factor */
-	prop = RNA_def_property(srna, "pen_smooth_steps", PROP_INT, PROP_NONE);
-	RNA_def_property_int_sdna(prop, NULL, "draw_smoothlvl");
-	RNA_def_property_range(prop, 1, 3);
-	RNA_def_property_ui_text(prop, "Iterations",
-	                         "Number of times to smooth newly created strokes "
-	                         "(smoothing strength is halved on each successive round of smoothing)");
-	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
-
-	/* Subdivision level for new strokes */
-	prop = RNA_def_property(srna, "pen_subdivision_steps", PROP_INT, PROP_NONE);
-	RNA_def_property_int_sdna(prop, NULL, "sublevel");
-	RNA_def_property_range(prop, 0, 3);
-	RNA_def_property_ui_text(prop, "Subdivision Steps",
-	                         "Number of times to subdivide newly created strokes, for less jagged strokes");
-	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
-
 	/* Flags */
 	prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
@@ -847,6 +1237,15 @@ static void rna_def_gpencil_layer(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Frame Locked", "Lock current frame displayed by layer");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 
+	/* Unlock colors */
+	prop = RNA_def_property(srna, "unlock_color", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_UNLOCK_COLOR);
+	RNA_def_property_ui_icon(prop, ICON_RESTRICT_COLOR_OFF, 1);
+	RNA_def_property_ui_text(prop, "Unlock color", "Unprotect colors selected from further editing "
+	                         "and/or frame changes");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
+
+
 	/* expose as layers.active */
 #if 0
 	prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
@@ -873,18 +1272,42 @@ static void rna_def_gpencil_layer(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "X Ray", "Make the layer draw in front of objects");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
 	
-	
-	/* Read-only state props (for simpler UI code) */
-	prop = RNA_def_property(srna, "is_stroke_visible", PROP_BOOLEAN, PROP_NONE);
-	RNA_def_property_boolean_funcs(prop, "rna_GPencilLayer_is_stroke_visible_get", NULL);
-	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-	RNA_def_property_ui_text(prop, "Is Stroke Visible", "True when opacity of stroke is set high enough to be visible");
-	
-	prop = RNA_def_property(srna, "is_fill_visible", PROP_BOOLEAN, PROP_NONE);
-	RNA_def_property_boolean_funcs(prop, "rna_GPencilLayer_is_fill_visible_get", NULL);
+	/* Parent object */
+	prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
+	RNA_def_property_pointer_funcs(prop, NULL, "rna_GPencilLayer_parent_set", NULL, NULL);
+	RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK); 
+	RNA_def_property_ui_text(prop, "Parent", "Parent Object");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* parent type */
+	prop = RNA_def_property(srna, "parent_type", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_bitflag_sdna(prop, NULL, "partype");
+	RNA_def_property_enum_items(prop, parent_type_items);
+	RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilLayer_parent_type_set", "rna_Object_parent_type_itemf");
+	RNA_def_property_ui_text(prop, "Parent Type", "Type of parent relation");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* parent bone */
+	prop = RNA_def_property(srna, "parent_bone", PROP_STRING, PROP_NONE);
+	RNA_def_property_string_sdna(prop, NULL, "parsubstr");
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_parent_bone_set");
+	RNA_def_property_ui_text(prop, "Parent Bone", "Name of parent bone in case of a bone parenting relation");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* matrix */
+	prop = RNA_def_property(srna, "matrix_inverse", PROP_FLOAT, PROP_MATRIX);
+	RNA_def_property_float_sdna(prop, NULL, "inverse");
+	RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
+	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
+	RNA_def_property_ui_text(prop, "MatrixInverse", "Parent inverse transformation matrix");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* read only parented flag */
+	prop = RNA_def_property(srna, "is_parented", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_funcs(prop, "rna_GPencilLayer_is_parented_get", NULL);
 	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-	RNA_def_property_ui_text(prop, "Is Fill Visible", "True when opacity of fill is set high enough to be visible");
-	
+	RNA_def_property_ui_text(prop, "Is Parented", "True when the layer parent object is set");
+
 	/* Layers API */
 	func = RNA_def_function(srna, "clear", "rna_GPencil_layer_clear");
 	RNA_def_function_ui_description(func, "Remove all the grease pencil layer data");
@@ -933,6 +1356,207 @@ static void rna_def_gpencil_layers_api(BlenderRNA *brna, PropertyRNA *cprop)
 	RNA_def_property_ui_text(prop, "Active Layer Index", "Index of active grease pencil layer");
 }
 
+static void rna_def_gpencil_palettecolor(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	srna = RNA_def_struct(brna, "GPencilPaletteColor", NULL);
+	RNA_def_struct_sdna(srna, "bGPDpalettecolor");
+	RNA_def_struct_ui_text(srna, "Grease Pencil Palette color", "Collection of related colors");
+	RNA_def_struct_path_func(srna, "rna_GPencilPalette_color_path");
+
+	/* Stroke Drawing Color */
+	prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
+	RNA_def_property_float_sdna(prop, NULL, "color");
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_range(prop, 0.0f, 1.0f);
+	RNA_def_property_ui_text(prop, "Color", "Color for strokes");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "color[3]");
+	RNA_def_property_range(prop, 0.0, 1.0f);
+	RNA_def_property_ui_text(prop, "Opacity", "Color Opacity");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* Name */
+	prop = RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
+	RNA_def_property_ui_text(prop, "Info", "Color name");
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilPaletteColor_info_set");
+	RNA_def_struct_name_property(srna, prop);
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* Fill Drawing Color */
+	prop = RNA_def_property(srna, "fill_color", PROP_FLOAT, PROP_COLOR_GAMMA);
+	RNA_def_property_float_sdna(prop, NULL, "fill");
+	RNA_def_property_array(prop, 3);
+	RNA_def_property_range(prop, 0.0f, 1.0f);
+	RNA_def_property_ui_text(prop, "Fill Color", "Color for filling region bounded by each stroke");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* Fill alpha */
+	prop = RNA_def_property(srna, "fill_alpha", PROP_FLOAT, PROP_NONE);
+	RNA_def_property_float_sdna(prop, NULL, "fill[3]");
+	RNA_def_property_range(prop, 0.0, 1.0f);
+	RNA_def_property_ui_text(prop, "Fill Opacity", "Opacity for filling region bounded by each stroke");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* Flags */
+	prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_HIDE);
+	RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
+	RNA_def_property_ui_text(prop, "Hide", "Set color Visibility");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_LOCKED);
+	RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
+	RNA_def_property_ui_text(prop, "Locked", "Protect color from further editing and/or frame changes");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	prop = RNA_def_property(srna, "ghost", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_ONIONSKIN);
+	RNA_def_property_ui_icon(prop, ICON_GHOST_ENABLED, 0);
+	RNA_def_property_ui_text(prop, "Ghost", "Display the color in onion skinning");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* Draw Style */
+	prop = RNA_def_property(srna, "use_volumetric_strokes", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_VOLUMETRIC);
+	RNA_def_property_ui_text(prop, "Volumetric Strokes", "Draw strokes as a series of circular blobs, resulting in "
+	                         "a volumetric effect");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* Use High quality fill */
+	prop = RNA_def_property(srna, "use_hq_fill", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_HQ_FILL);
+	RNA_def_property_ui_text(prop, "High Quality Fill", "Fill strokes using high quality to avoid glitches "
+	                         "(slower fps during animation play)");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* Read-only state props (for simpler UI code) */
+	prop = RNA_def_property(srna, "is_stroke_visible", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_funcs(prop, "rna_GPencilPaletteColor_is_stroke_visible_get", NULL);
+	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Is Stroke Visible", "True when opacity of stroke is set high enough to be visible");
+
+	prop = RNA_def_property(srna, "is_fill_visible", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_funcs(prop, "rna_GPencilPaletteColor_is_fill_visible_get", NULL);
+	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Is Fill Visible", "True when opacity of fill is set high enough to be visible");
+}
+
+/* palette colors api */
+static void rna_def_gpencil_palettecolors_api(BlenderRNA *brna, PropertyRNA *cprop)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	FunctionRNA *func;
+	PropertyRNA *parm;
+
+	RNA_def_property_srna(cprop, "GPencilPaletteColors");
+	srna = RNA_def_struct(brna, "GPencilPaletteColors", NULL);
+	RNA_def_struct_sdna(srna, "bGPDpalette");
+	RNA_def_struct_ui_text(srna, "Palette colors", "Collection of palette colors");
+
+	func = RNA_def_function(srna, "new", "rna_GPencilPalette_color_new");
+	RNA_def_function_ui_description(func, "Add a new color to the palette");
+	parm = RNA_def_pointer(func, "color", "GPencilPaletteColor", "", "The newly created color");
+	RNA_def_function_return(func, parm);
+
+	func = RNA_def_function(srna, "remove", "rna_GPencilPalette_color_remove");
+	RNA_def_function_ui_description(func, "Remove a color from the palette");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS);
+	parm = RNA_def_pointer(func, "color", "GPencilPaletteColor", "", "The color to remove");
+	RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
+	RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
+
+	prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "GPencilPaletteColor");
+	RNA_def_property_pointer_funcs(prop, "rna_GPencilPalette_active_color_get", "rna_GPencilPalette_active_color_set", NULL, NULL);
+	RNA_def_property_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Active Palette Color", "Current active color");
+
+	prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_funcs(prop,
+		"rna_GPencilPaletteColor_index_get",
+		"rna_GPencilPaletteColor_index_set",
+		"rna_GPencilPaletteColor_index_range");
+	RNA_def_property_ui_text(prop, "Active color Index", "Index of active palette color");
+}
+
+static void rna_def_gpencil_palette(BlenderRNA *brna)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	srna = RNA_def_struct(brna, "GPencilPalette", NULL);
+	RNA_def_struct_sdna(srna, "bGPDpalette");
+	RNA_def_struct_ui_text(srna, "Grease Pencil Palette", "Collection of related palettes");
+	RNA_def_struct_ui_icon(srna, ICON_COLOR);
+
+	/* Name */
+	prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+	RNA_def_property_string_sdna(prop, NULL, "info");
+	RNA_def_property_ui_text(prop, "Name", "Palette name");
+	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilPalette_info_set");
+	RNA_def_struct_name_property(srna, prop);
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
+	/* Colors */
+	prop = RNA_def_property(srna, "colors", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "colors", NULL);
+	RNA_def_property_struct_type(prop, "GPencilPaletteColor");
+	RNA_def_property_ui_text(prop, "Colors", "Colors of the palette");
+	rna_def_gpencil_palettecolors_api(brna, prop);
+
+}
+
+static void rna_def_gpencil_palettes_api(BlenderRNA *brna, PropertyRNA *cprop)
+{
+	StructRNA *srna;
+	PropertyRNA *prop;
+
+	FunctionRNA *func;
+	PropertyRNA *parm;
+
+	RNA_def_property_srna(cprop, "GreasePencilPalettes");
+	srna = RNA_def_struct(brna, "GreasePencilPalettes", NULL);
+	RNA_def_struct_sdna(srna, "bGPdata");
+	RNA_def_struct_ui_text(srna, "Grease Pencil Palettes", "Collection of grease pencil palettes");
+
+	func = RNA_def_function(srna, "new", "rna_GPencil_palette_new");
+	RNA_def_function_ui_description(func, "Add a new grease pencil palette");
+	parm = RNA_def_string(func, "name", "GPencilPalette", MAX_NAME, "Name", "Name of the palette");
+	RNA_def_property_flag(parm, PROP_REQUIRED);
+	RNA_def_boolean(func, "set_active", 0, "Set Active", "Activate the newly created palette");
+	parm = RNA_def_pointer(func, "palette", "GPencilPalette", "", "The newly created palette");
+	RNA_def_function_return(func, parm);
+
+	func = RNA_def_function(srna, "remove", "rna_GPencil_palette_remove");
+	RNA_def_function_ui_description(func, "Remove a grease pencil palette");
+	RNA_def_function_flag(func, FUNC_USE_REPORTS);
+	parm = RNA_def_pointer(func, "palette", "GPencilPalette", "", "The palette to remove");
+	RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
+	RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
+
+	prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
+	RNA_def_property_struct_type(prop, "GPencilPalette");
+	RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_palette_get", "rna_GPencil_active_palette_set",
+	                               NULL, NULL);
+	RNA_def_property_flag(prop, PROP_EDITABLE);
+	RNA_def_property_ui_text(prop, "Active Palette", "Current active palette");
+
+	prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_funcs(prop,
+		"rna_GPencilPalette_index_get",
+		"rna_GPencilPalette_index_set",
+		"rna_GPencilPalette_index_range");
+	RNA_def_property_ui_text(prop, "Active Palette Index", "Index of active palette");
+}
+
 static void rna_def_gpencil_data(BlenderRNA *brna)
 {
 	StructRNA *srna;
@@ -951,6 +1575,13 @@ static void rna_def_gpencil_data(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Layers", "");
 	rna_def_gpencil_layers_api(brna, prop);
 	
+	/* Palettes */
+	prop = RNA_def_property(srna, "palettes", PROP_COLLECTION, PROP_NONE);
+	RNA_def_property_collection_sdna(prop, NULL, "palettes", NULL);
+	RNA_def_property_struct_type(prop, "GPencilPalette");
+	RNA_def_property_ui_text(prop, "Palettes", "");
+	rna_def_gpencil_palettes_api(brna, prop);
+
 	/* Animation Data */
 	rna_def_animdata_common(srna);
 	
@@ -967,6 +1598,12 @@ static void rna_def_gpencil_data(BlenderRNA *brna)
 	                         "Show ghosts of the frames before and after the current frame, toggle to enable on active layer or disable all");
 	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 	
+	prop = RNA_def_property(srna, "show_stroke_direction", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_DIRECTION);
+	RNA_def_property_ui_text(prop, "Show Direction", "Show stroke drawing direction with a bigger green dot (start) "
+	                         "and smaller red dot (end) points");
+	RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
+
 	/* API Functions */
 	func = RNA_def_function(srna, "clear", "rna_GPencil_clear");
 	RNA_def_function_ui_description(func, "Remove all the grease pencil data");
@@ -980,8 +1617,12 @@ void RNA_def_gpencil(BlenderRNA *brna)
 
 	rna_def_gpencil_layer(brna);
 	rna_def_gpencil_frame(brna);
+	rna_def_gpencil_triangle(brna);
 	rna_def_gpencil_stroke(brna);
 	rna_def_gpencil_stroke_point(brna);
+
+	rna_def_gpencil_palette(brna);
+	rna_def_gpencil_palettecolor(brna);
 }
 
 #endif