blender
/
blender
132
398
Fork 577
Code Issues 6.2k Pull Requests 748 Projects 19 Wiki Activity

Cleanup: Use BKE_gpencil prefix 

This is a good point to change this as grease-pencil-v2 branch was just merged, so I hope merge conflicts with other branches are minimal.
This commit is contained in:
Julian Eisel 2016-08-04 15:03:18 +02:00
parent 5f63797c09
commit 357480f8c3
Notes: blender-bot 2023-02-14 09:43:37 +01:00 
Referenced by issue #49023, Segfault when switching brushes while renaming another brush
23 changed files with 301 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
source/blender/blenkernel/BKE_gpencil.h
View File

@ -43,36 +43,36 @@ struct Main;
/* ------------ Grease-Pencil API ------------------ */
void free_gpencil_stroke(struct bGPDstroke *gps);
bool free_gpencil_strokes(struct bGPDframe *gpf);
void free_gpencil_frames(struct bGPDlayer *gpl);
void free_gpencil_layers(struct ListBase *list);
void free_gpencil_brushes(struct ListBase *list);
void free_gpencil_palettes(struct ListBase *list);
void BKE_gpencil_free_stroke(struct bGPDstroke *gps);
bool BKE_gpencil_free_strokes(struct bGPDframe *gpf);
void BKE_gpencil_free_frames(struct bGPDlayer *gpl);
void BKE_gpencil_free_layers(struct ListBase *list);
void BKE_gpencil_free_brushes(struct ListBase *list);
void BKE_gpencil_free_palettes(struct ListBase *list);
void BKE_gpencil_free(struct bGPdata *gpd, bool free_palettes);
void gpencil_stroke_sync_selection(struct bGPDstroke *gps);
void BKE_gpencil_stroke_sync_selection(struct bGPDstroke *gps);
struct bGPDframe *gpencil_frame_addnew(struct bGPDlayer *gpl, int cframe);
struct bGPDframe *gpencil_frame_addcopy(struct bGPDlayer *gpl, int cframe);
struct bGPDlayer *gpencil_layer_addnew(struct bGPdata *gpd, const char *name, bool setactive);
struct bGPdata *gpencil_data_addnew(const char name[]);
struct bGPDframe *BKE_gpencil_frame_addnew(struct bGPDlayer *gpl, int cframe);
struct bGPDframe *BKE_gpencil_frame_addcopy(struct bGPDlayer *gpl, int cframe);
struct bGPDlayer *BKE_gpencil_layer_addnew(struct bGPdata *gpd, const char *name, bool setactive);
struct bGPdata *BKE_gpencil_data_addnew(const char name[]);
struct bGPDframe *gpencil_frame_duplicate(const struct bGPDframe *gpf_src);
struct bGPDlayer *gpencil_layer_duplicate(const struct bGPDlayer *gpl_src);
struct bGPdata *gpencil_data_duplicate(struct Main *bmain, struct bGPdata *gpd, bool internal_copy);
struct bGPDframe *BKE_gpencil_frame_duplicate(const struct bGPDframe *gpf_src);
struct bGPDlayer *BKE_gpencil_layer_duplicate(const struct bGPDlayer *gpl_src);
struct bGPdata *BKE_gpencil_data_duplicate(struct Main *bmain, struct bGPdata *gpd, bool internal_copy);
void BKE_gpencil_make_local(struct Main *bmain, struct bGPdata *gpd, const bool lib_local);
void gpencil_frame_delete_laststroke(struct bGPDlayer *gpl, struct bGPDframe *gpf);
void BKE_gpencil_frame_delete_laststroke(struct bGPDlayer *gpl, struct bGPDframe *gpf);
struct bGPDpalette *gpencil_palette_addnew(struct bGPdata *gpd, const char *name, bool setactive);
struct bGPDpalette *gpencil_palette_duplicate(const struct bGPDpalette *palette_src);
struct bGPDpalettecolor *gpencil_palettecolor_addnew(struct bGPDpalette *palette, const char *name, bool setactive);
struct bGPDpalette *BKE_gpencil_palette_addnew(struct bGPdata *gpd, const char *name, bool setactive);
struct bGPDpalette *BKE_gpencil_palette_duplicate(const struct bGPDpalette *palette_src);
struct bGPDpalettecolor *BKE_gpencil_palettecolor_addnew(struct bGPDpalette *palette, const char *name, bool setactive);
struct bGPDbrush *gpencil_brush_addnew(struct ToolSettings *ts, const char *name, bool setactive);
struct bGPDbrush *gpencil_brush_duplicate(const struct bGPDbrush *brush_src);
void gpencil_brush_init_presets(struct ToolSettings *ts);
struct bGPDbrush *BKE_gpencil_brush_addnew(struct ToolSettings *ts, const char *name, bool setactive);
struct bGPDbrush *BKE_gpencil_brush_duplicate(const struct bGPDbrush *brush_src);
void BKE_gpencil_brush_init_presets(struct ToolSettings *ts);
/* Stroke and Fill - Alpha Visibility Threshold */
@ -94,28 +94,28 @@ typedef enum eGP_GetFrame_Mode {
GP_GETFRAME_ADD_COPY = 2
} eGP_GetFrame_Mode;
struct bGPDframe *gpencil_layer_getframe(struct bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew);
struct bGPDframe *BKE_gpencil_layer_getframe(struct bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew);
struct bGPDframe *BKE_gpencil_layer_find_frame(struct bGPDlayer *gpl, int cframe);
bool gpencil_layer_delframe(struct bGPDlayer *gpl, struct bGPDframe *gpf);
bool BKE_gpencil_layer_delframe(struct bGPDlayer *gpl, struct bGPDframe *gpf);
struct bGPDlayer *gpencil_layer_getactive(struct bGPdata *gpd);
void gpencil_layer_setactive(struct bGPdata *gpd, struct bGPDlayer *active);
void gpencil_layer_delete(struct bGPdata *gpd, struct bGPDlayer *gpl);
struct bGPDlayer *BKE_gpencil_layer_getactive(struct bGPdata *gpd);
void BKE_gpencil_layer_setactive(struct bGPdata *gpd, struct bGPDlayer *active);
void BKE_gpencil_layer_delete(struct bGPdata *gpd, struct bGPDlayer *gpl);
struct bGPDbrush *gpencil_brush_getactive(struct ToolSettings *ts);
void gpencil_brush_setactive(struct ToolSettings *ts, struct bGPDbrush *active);
void gpencil_brush_delete(struct ToolSettings *ts, struct bGPDbrush *palette);
struct bGPDbrush *BKE_gpencil_brush_getactive(struct ToolSettings *ts);
void BKE_gpencil_brush_setactive(struct ToolSettings *ts, struct bGPDbrush *active);
void BKE_gpencil_brush_delete(struct ToolSettings *ts, struct bGPDbrush *palette);
struct bGPDpalette *gpencil_palette_getactive(struct bGPdata *gpd);
void gpencil_palette_setactive(struct bGPdata *gpd, struct bGPDpalette *active);
void gpencil_palette_delete(struct bGPdata *gpd, struct bGPDpalette *palette);
void gpencil_palette_change_strokes(struct bGPdata *gpd);
struct bGPDpalette *BKE_gpencil_palette_getactive(struct bGPdata *gpd);
void BKE_gpencil_palette_setactive(struct bGPdata *gpd, struct bGPDpalette *active);
void BKE_gpencil_palette_delete(struct bGPdata *gpd, struct bGPDpalette *palette);
void BKE_gpencil_palette_change_strokes(struct bGPdata *gpd);
struct bGPDpalettecolor *gpencil_palettecolor_getactive(struct bGPDpalette *palette);
void gpencil_palettecolor_setactive(struct bGPDpalette *palette, struct bGPDpalettecolor *active);
void gpencil_palettecolor_delete(struct bGPDpalette *palette, struct bGPDpalettecolor *palcolor);
struct bGPDpalettecolor *gpencil_palettecolor_getbyname(struct bGPDpalette *palette, char *name);
void gpencil_palettecolor_changename(struct bGPdata *gpd, char *oldname, const char *newname);
void gpencil_palettecolor_delete_strokes(struct bGPdata *gpd, char *name);
struct bGPDpalettecolor *BKE_gpencil_palettecolor_getactive(struct bGPDpalette *palette);
void BKE_gpencil_palettecolor_setactive(struct bGPDpalette *palette, struct bGPDpalettecolor *active);
void BKE_gpencil_palettecolor_delete(struct bGPDpalette *palette, struct bGPDpalettecolor *palcolor);
struct bGPDpalettecolor *BKE_gpencil_palettecolor_getbyname(struct bGPDpalette *palette, char *name);
void BKE_gpencil_palettecolor_changename(struct bGPdata *gpd, char *oldname, const char *newname);
void BKE_gpencil_palettecolor_delete_strokes(struct bGPdata *gpd, char *name);
#endif /* __BKE_GPENCIL_H__ */

144
source/blender/blenkernel/intern/gpencil.c
View File

@ -60,7 +60,7 @@
/* --------- Memory Management ------------ */
/* free stroke, doesn't unlink from any listbase */
void free_gpencil_stroke(bGPDstroke *gps)
void BKE_gpencil_free_stroke(bGPDstroke *gps)
{
if (gps == NULL) {
return;
@ -76,7 +76,7 @@ void free_gpencil_stroke(bGPDstroke *gps)
}
/* Free strokes belonging to a gp-frame */
bool free_gpencil_strokes(bGPDframe *gpf)
bool BKE_gpencil_free_strokes(bGPDframe *gpf)
{
bGPDstroke *gps_next;
bool changed = (BLI_listbase_is_empty(&gpf->strokes) == false);
@ -84,7 +84,7 @@ bool free_gpencil_strokes(bGPDframe *gpf)
/* free strokes */
for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps_next) {
gps_next = gps->next;
free_gpencil_stroke(gps);
BKE_gpencil_free_stroke(gps);
}
BLI_listbase_clear(&gpf->strokes);
@ -92,7 +92,7 @@ bool free_gpencil_strokes(bGPDframe *gpf)
}
/* Free all of a gp-layer's frames */
void free_gpencil_frames(bGPDlayer *gpl)
void BKE_gpencil_free_frames(bGPDlayer *gpl)
{
bGPDframe *gpf_next;
@ -104,7 +104,7 @@ void free_gpencil_frames(bGPDlayer *gpl)
gpf_next = gpf->next;
/* free strokes and their associated memory */
free_gpencil_strokes(gpf);
BKE_gpencil_free_strokes(gpf);
BLI_freelinkN(&gpl->frames, gpf);
}
gpl->actframe = NULL;
@ -123,7 +123,7 @@ static void free_gpencil_colors(bGPDpalette *palette)
}
/* Free all of the gp-palettes and colors */
void free_gpencil_palettes(ListBase *list)
void BKE_gpencil_free_palettes(ListBase *list)
{
bGPDpalette *palette_next;
@ -144,7 +144,7 @@ void free_gpencil_palettes(ListBase *list)
}
/* Free all of the gp-brushes for a viewport (list should be &gpd->brushes or so) */
void free_gpencil_brushes(ListBase *list)
void BKE_gpencil_free_brushes(ListBase *list)
{
bGPDbrush *brush_next;
@ -173,7 +173,7 @@ void free_gpencil_brushes(ListBase *list)
}
/* Free all of the gp-layers for a viewport (list should be &gpd->layers or so) */
void free_gpencil_layers(ListBase *list)
void BKE_gpencil_free_layers(ListBase *list)
{
bGPDlayer *gpl_next;
@ -185,7 +185,7 @@ void free_gpencil_layers(ListBase *list)
gpl_next = gpl->next;
/* free layers and their data */
free_gpencil_frames(gpl);
BKE_gpencil_free_frames(gpl);
BLI_freelinkN(list, gpl);
}
}
@ -196,18 +196,18 @@ void BKE_gpencil_free(bGPdata *gpd, bool free_palettes)
BKE_animdata_free(&gpd->id, false);
/* free layers */
free_gpencil_layers(&gpd->layers);
BKE_gpencil_free_layers(&gpd->layers);
/* free palettes */
if (free_palettes) {
free_gpencil_palettes(&gpd->palettes);
BKE_gpencil_free_palettes(&gpd->palettes);
}
}
/* -------- Container Creation ---------- */
/* add a new gp-frame to the given layer */
bGPDframe *gpencil_frame_addnew(bGPDlayer *gpl, int cframe)
bGPDframe *BKE_gpencil_frame_addnew(bGPDlayer *gpl, int cframe)
{
bGPDframe *gpf = NULL, *gf = NULL;
short state = 0;
@ -259,7 +259,7 @@ bGPDframe *gpencil_frame_addnew(bGPDlayer *gpl, int cframe)
}
/* add a copy of the active gp-frame to the given layer */
bGPDframe *gpencil_frame_addcopy(bGPDlayer *gpl, int cframe)
bGPDframe *BKE_gpencil_frame_addcopy(bGPDlayer *gpl, int cframe)
{
bGPDframe *new_frame;
bool found = false;
@ -271,11 +271,11 @@ bGPDframe *gpencil_frame_addcopy(bGPDlayer *gpl, int cframe)
}
else if (gpl->actframe == NULL) {
/* no active frame, so just create a new one from scratch */
return gpencil_frame_addnew(gpl, cframe);
return BKE_gpencil_frame_addnew(gpl, cframe);
}
/* Create a copy of the frame */
new_frame = gpencil_frame_duplicate(gpl->actframe);
new_frame = BKE_gpencil_frame_duplicate(gpl->actframe);
/* Find frame to insert it before */
for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
@ -290,7 +290,7 @@ bGPDframe *gpencil_frame_addcopy(bGPDlayer *gpl, int cframe)
/* This only happens when we're editing with framelock on...
* - Delete the new frame and don't do anything else here...
*/
free_gpencil_strokes(new_frame);
BKE_gpencil_free_strokes(new_frame);
MEM_freeN(new_frame);
new_frame = NULL;
@ -314,7 +314,7 @@ bGPDframe *gpencil_frame_addcopy(bGPDlayer *gpl, int cframe)
}
/* add a new gp-layer and make it the active layer */
bGPDlayer *gpencil_layer_addnew(bGPdata *gpd, const char *name, bool setactive)
bGPDlayer *BKE_gpencil_layer_addnew(bGPdata *gpd, const char *name, bool setactive)
{
bGPDlayer *gpl;
@ -353,14 +353,14 @@ bGPDlayer *gpencil_layer_addnew(bGPdata *gpd, const char *name, bool setactive)
/* make this one the active one */
if (setactive)
gpencil_layer_setactive(gpd, gpl);
BKE_gpencil_layer_setactive(gpd, gpl);
/* return layer */
return gpl;
}
/* add a new gp-palette and make it the active */
bGPDpalette *gpencil_palette_addnew(bGPdata *gpd, const char *name, bool setactive)
bGPDpalette *BKE_gpencil_palette_addnew(bGPdata *gpd, const char *name, bool setactive)
{
bGPDpalette *palette;
@ -383,7 +383,7 @@ bGPDpalette *gpencil_palette_addnew(bGPdata *gpd, const char *name, bool setacti
/* make this one the active one */
if (setactive) {
gpencil_palette_setactive(gpd, palette);
BKE_gpencil_palette_setactive(gpd, palette);
}
/* return palette */
@ -391,11 +391,11 @@ bGPDpalette *gpencil_palette_addnew(bGPdata *gpd, const char *name, bool setacti
}
/* create a set of default drawing brushes with predefined presets */
void gpencil_brush_init_presets(ToolSettings *ts)
void BKE_gpencil_brush_init_presets(ToolSettings *ts)
{
bGPDbrush *brush;
/* Basic brush */
brush = gpencil_brush_addnew(ts, "Basic", true);
brush = BKE_gpencil_brush_addnew(ts, "Basic", true);
brush->thickness = 3.0f;
brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
brush->draw_sensitivity = 1.0f;
@ -419,7 +419,7 @@ void gpencil_brush_init_presets(ToolSettings *ts)
brush->draw_random_sub = 0.0f;
/* Pencil brush */
brush = gpencil_brush_addnew(ts, "Pencil", false);
brush = BKE_gpencil_brush_addnew(ts, "Pencil", false);
brush->thickness = 7.0f;
brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
brush->draw_sensitivity = 1.0f;
@ -443,7 +443,7 @@ void gpencil_brush_init_presets(ToolSettings *ts)
brush->draw_random_sub = 0.0f;
/* Ink brush */
brush = gpencil_brush_addnew(ts, "Ink", false);
brush = BKE_gpencil_brush_addnew(ts, "Ink", false);
brush->thickness = 7.0f;
brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
brush->draw_sensitivity = 1.6f;
@ -467,7 +467,7 @@ void gpencil_brush_init_presets(ToolSettings *ts)
brush->draw_random_sub = 0.0f;
/* Ink Noise brush */
brush = gpencil_brush_addnew(ts, "Ink noise", false);
brush = BKE_gpencil_brush_addnew(ts, "Ink noise", false);
brush->thickness = 6.0f;
brush->flag |= GP_BRUSH_USE_RANDOM_PRESSURE;
brush->draw_sensitivity = 1.611f;
@ -491,7 +491,7 @@ void gpencil_brush_init_presets(ToolSettings *ts)
brush->draw_random_sub = 0.0f;
/* Marker brush */
brush = gpencil_brush_addnew(ts, "Marker", false);
brush = BKE_gpencil_brush_addnew(ts, "Marker", false);
brush->thickness = 10.0f;
brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
brush->draw_sensitivity = 2.0f;
@ -515,7 +515,7 @@ void gpencil_brush_init_presets(ToolSettings *ts)
brush->draw_random_sub = 0.0f;
/* Crayon brush */
brush = gpencil_brush_addnew(ts, "Crayon", false);
brush = BKE_gpencil_brush_addnew(ts, "Crayon", false);
brush->thickness = 10.0f;
brush->flag &= ~GP_BRUSH_USE_RANDOM_PRESSURE;
brush->draw_sensitivity = 3.0f;
@ -541,7 +541,7 @@ void gpencil_brush_init_presets(ToolSettings *ts)
}
/* add a new gp-brush and make it the active */
bGPDbrush *gpencil_brush_addnew(ToolSettings *ts, const char *name, bool setactive)
bGPDbrush *BKE_gpencil_brush_addnew(ToolSettings *ts, const char *name, bool setactive)
{
bGPDbrush *brush;
@ -577,7 +577,7 @@ bGPDbrush *gpencil_brush_addnew(ToolSettings *ts, const char *name, bool setacti
/* make this one the active one */
if (setactive) {
gpencil_brush_setactive(ts, brush);
BKE_gpencil_brush_setactive(ts, brush);
}
/* return brush */
@ -585,7 +585,7 @@ bGPDbrush *gpencil_brush_addnew(ToolSettings *ts, const char *name, bool setacti
}
/* add a new gp-palettecolor and make it the active */
bGPDpalettecolor *gpencil_palettecolor_addnew(bGPDpalette *palette, const char *name, bool setactive)
bGPDpalettecolor *BKE_gpencil_palettecolor_addnew(bGPDpalette *palette, const char *name, bool setactive)
{
bGPDpalettecolor *palcolor;
@ -612,7 +612,7 @@ bGPDpalettecolor *gpencil_palettecolor_addnew(bGPDpalette *palette, const char *
/* make this one the active one */
if (setactive) {
gpencil_palettecolor_setactive(palette, palcolor);
BKE_gpencil_palettecolor_setactive(palette, palcolor);
}
/* return palette color */
@ -620,7 +620,7 @@ bGPDpalettecolor *gpencil_palettecolor_addnew(bGPDpalette *palette, const char *
}
/* add a new gp-datablock */
bGPdata *gpencil_data_addnew(const char name[])
bGPdata *BKE_gpencil_data_addnew(const char name[])
{
bGPdata *gpd;
@ -641,7 +641,7 @@ bGPdata *gpencil_data_addnew(const char name[])
/* -------- Data Duplication ---------- */
/* make a copy of a given gpencil frame */
bGPDframe *gpencil_frame_duplicate(const bGPDframe *gpf_src)
bGPDframe *BKE_gpencil_frame_duplicate(const bGPDframe *gpf_src)
{
bGPDstroke *gps_dst;
bGPDframe *gpf_dst;
@ -671,7 +671,7 @@ bGPDframe *gpencil_frame_duplicate(const bGPDframe *gpf_src)
}
/* make a copy of a given gpencil brush */
bGPDbrush *gpencil_brush_duplicate(const bGPDbrush *brush_src)
bGPDbrush *BKE_gpencil_brush_duplicate(const bGPDbrush *brush_src)
{
bGPDbrush *brush_dst;
@ -693,7 +693,7 @@ bGPDbrush *gpencil_brush_duplicate(const bGPDbrush *brush_src)
}
/* make a copy of a given gpencil palette */
bGPDpalette *gpencil_palette_duplicate(const bGPDpalette *palette_src)
bGPDpalette *BKE_gpencil_palette_duplicate(const bGPDpalette *palette_src)
{
bGPDpalette *palette_dst;
const bGPDpalettecolor *palcolor_src;
@ -720,7 +720,7 @@ bGPDpalette *gpencil_palette_duplicate(const bGPDpalette *palette_src)
return palette_dst;
}
/* make a copy of a given gpencil layer */
bGPDlayer *gpencil_layer_duplicate(const bGPDlayer *gpl_src)
bGPDlayer *BKE_gpencil_layer_duplicate(const bGPDlayer *gpl_src)
{
const bGPDframe *gpf_src;
bGPDframe *gpf_dst;
@ -739,7 +739,7 @@ bGPDlayer *gpencil_layer_duplicate(const bGPDlayer *gpl_src)
BLI_listbase_clear(&gpl_dst->frames);
for (gpf_src = gpl_src->frames.first; gpf_src; gpf_src = gpf_src->next) {
/* make a copy of source frame */
gpf_dst = gpencil_frame_duplicate(gpf_src);
gpf_dst = BKE_gpencil_frame_duplicate(gpf_src);
BLI_addtail(&gpl_dst->frames, gpf_dst);
/* if source frame was the current layer's 'active' frame, reassign that too */
@ -752,7 +752,7 @@ bGPDlayer *gpencil_layer_duplicate(const bGPDlayer *gpl_src)
}
/* make a copy of a given gpencil datablock */
bGPdata *gpencil_data_duplicate(Main *bmain, bGPdata *gpd_src, bool internal_copy)
bGPdata *BKE_gpencil_data_duplicate(Main *bmain, bGPdata *gpd_src, bool internal_copy)
{
const bGPDlayer *gpl_src;
bGPDlayer *gpl_dst;
@ -777,7 +777,7 @@ bGPdata *gpencil_data_duplicate(Main *bmain, bGPdata *gpd_src, bool internal_cop
BLI_listbase_clear(&gpd_dst->layers);
for (gpl_src = gpd_src->layers.first; gpl_src; gpl_src = gpl_src->next) {
/* make a copy of source layer and its data */
gpl_dst = gpencil_layer_duplicate(gpl_src);
gpl_dst = BKE_gpencil_layer_duplicate(gpl_src);
BLI_addtail(&gpd_dst->layers, gpl_dst);
}
if (!internal_copy) {
@ -785,7 +785,7 @@ bGPdata *gpencil_data_duplicate(Main *bmain, bGPdata *gpd_src, bool internal_cop
bGPDpalette *palette_src, *palette_dst;
BLI_listbase_clear(&gpd_dst->palettes);
for (palette_src = gpd_src->palettes.first; palette_src; palette_src = palette_src->next) {
palette_dst = gpencil_palette_duplicate(palette_src);
palette_dst = BKE_gpencil_palette_duplicate(palette_src);
BLI_addtail(&gpd_dst->palettes, palette_dst);
}
}
@ -802,7 +802,7 @@ void BKE_gpencil_make_local(Main *bmain, bGPdata *gpd, const bool lib_local)
/* -------- GP-Stroke API --------- */
/* ensure selection status of stroke is in sync with its points */
void gpencil_stroke_sync_selection(bGPDstroke *gps)
void BKE_gpencil_stroke_sync_selection(bGPDstroke *gps)
{
bGPDspoint *pt;
int i;
@ -827,7 +827,7 @@ void gpencil_stroke_sync_selection(bGPDstroke *gps)
/* -------- GP-Frame API ---------- */
/* delete the last stroke of the given frame */
void gpencil_frame_delete_laststroke(bGPDlayer *gpl, bGPDframe *gpf)
void BKE_gpencil_frame_delete_laststroke(bGPDlayer *gpl, bGPDframe *gpf)
{
bGPDstroke *gps = (gpf) ? gpf->strokes.last : NULL;
int cfra = (gpf) ? gpf->framenum : 0; /* assume that the current frame was not locked */
@ -843,8 +843,8 @@ void gpencil_frame_delete_laststroke(bGPDlayer *gpl, bGPDframe *gpf)
/* if frame has no strokes after this, delete it */
if (BLI_listbase_is_empty(&gpf->strokes)) {
gpencil_layer_delframe(gpl, gpf);
gpencil_layer_getframe(gpl, cfra, 0);
BKE_gpencil_layer_delframe(gpl, gpf);
BKE_gpencil_layer_getframe(gpl, cfra, 0);
}
}
@ -892,7 +892,7 @@ bGPDframe *BKE_gpencil_layer_find_frame(bGPDlayer *gpl, int cframe)
* - this sets the layer's actframe var (if allowed to)
* - extension beyond range (if first gp-frame is after all frame in interest and cannot add)
*/
bGPDframe *gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
bGPDframe *BKE_gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
{
bGPDframe *gpf = NULL;
short found = 0;
@ -931,9 +931,9 @@ bGPDframe *gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode
if ((found) && (gpf->framenum == cframe))
gpl->actframe = gpf;
else if (addnew == GP_GETFRAME_ADD_COPY)
gpl->actframe = gpencil_frame_addcopy(gpl, cframe);
gpl->actframe = BKE_gpencil_frame_addcopy(gpl, cframe);
else
gpl->actframe = gpencil_frame_addnew(gpl, cframe);
gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
}
else if (found)
gpl->actframe = gpf;
@ -953,9 +953,9 @@ bGPDframe *gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode
if ((found) && (gpf->framenum == cframe))
gpl->actframe = gpf;
else if (addnew == GP_GETFRAME_ADD_COPY)
gpl->actframe = gpencil_frame_addcopy(gpl, cframe);
gpl->actframe = BKE_gpencil_frame_addcopy(gpl, cframe);
else
gpl->actframe = gpencil_frame_addnew(gpl, cframe);
gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
}
else if (found)
gpl->actframe = gpf;
@ -992,7 +992,7 @@ bGPDframe *gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode
if ((found) && (gpf->framenum == cframe))
gpl->actframe = gpf;
else
gpl->actframe = gpencil_frame_addnew(gpl, cframe);
gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
}
else if (found)
gpl->actframe = gpf;
@ -1005,7 +1005,7 @@ bGPDframe *gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode
else {
/* currently no frames (add if allowed to) */
if (addnew)
gpl->actframe = gpencil_frame_addnew(gpl, cframe);
gpl->actframe = BKE_gpencil_frame_addnew(gpl, cframe);
else {
/* don't do anything... this may be when no frames yet! */
/* gpl->actframe should still be NULL */
@ -1017,7 +1017,7 @@ bGPDframe *gpencil_layer_getframe(bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode
}
/* delete the given frame from a layer */
bool gpencil_layer_delframe(bGPDlayer *gpl, bGPDframe *gpf)
bool BKE_gpencil_layer_delframe(bGPDlayer *gpl, bGPDframe *gpf)
{
bool changed = false;
@ -1034,14 +1034,14 @@ bool gpencil_layer_delframe(bGPDlayer *gpl, bGPDframe *gpf)
gpl->actframe = NULL;
/* free the frame and its data */
changed = free_gpencil_strokes(gpf);
changed = BKE_gpencil_free_strokes(gpf);
BLI_freelinkN(&gpl->frames, gpf);
return changed;
}
/* get the active gp-layer for editing */
bGPDlayer *gpencil_layer_getactive(bGPdata *gpd)
bGPDlayer *BKE_gpencil_layer_getactive(bGPdata *gpd)
{
bGPDlayer *gpl;
@ -1060,7 +1060,7 @@ bGPDlayer *gpencil_layer_getactive(bGPdata *gpd)
}
/* set the active gp-layer */
void gpencil_layer_setactive(bGPdata *gpd, bGPDlayer *active)
void BKE_gpencil_layer_setactive(bGPdata *gpd, bGPDlayer *active)
{
bGPDlayer *gpl;
@ -1077,20 +1077,20 @@ void gpencil_layer_setactive(bGPdata *gpd, bGPDlayer *active)
}
/* delete the active gp-layer */
void gpencil_layer_delete(bGPdata *gpd, bGPDlayer *gpl)
void BKE_gpencil_layer_delete(bGPdata *gpd, bGPDlayer *gpl)
{
/* error checking */
if (ELEM(NULL, gpd, gpl))
return;
/* free layer */
free_gpencil_frames(gpl);
BKE_gpencil_free_frames(gpl);
BLI_freelinkN(&gpd->layers, gpl);
}
/* ************************************************** */
/* get the active gp-brush for editing */
bGPDbrush *gpencil_brush_getactive(ToolSettings *ts)
bGPDbrush *BKE_gpencil_brush_getactive(ToolSettings *ts)
{
bGPDbrush *brush;
@ -1111,7 +1111,7 @@ bGPDbrush *gpencil_brush_getactive(ToolSettings *ts)
}
/* set the active gp-brush */
void gpencil_brush_setactive(ToolSettings *ts, bGPDbrush *active)
void BKE_gpencil_brush_setactive(ToolSettings *ts, bGPDbrush *active)
{
bGPDbrush *brush;
@ -1130,7 +1130,7 @@ void gpencil_brush_setactive(ToolSettings *ts, bGPDbrush *active)
}
/* delete the active gp-brush */
void gpencil_brush_delete(ToolSettings *ts, bGPDbrush *brush)
void BKE_gpencil_brush_delete(ToolSettings *ts, bGPDbrush *brush)
{
/* error checking */
if (ELEM(NULL, ts, brush)) {
@ -1154,7 +1154,7 @@ void gpencil_brush_delete(ToolSettings *ts, bGPDbrush *brush)
/* ************************************************** */
/* get the active gp-palette for editing */
bGPDpalette *gpencil_palette_getactive(bGPdata *gpd)
bGPDpalette *BKE_gpencil_palette_getactive(bGPdata *gpd)
{
bGPDpalette *palette;
@ -1174,7 +1174,7 @@ bGPDpalette *gpencil_palette_getactive(bGPdata *gpd)
}
/* set the active gp-palette */
void gpencil_palette_setactive(bGPdata *gpd, bGPDpalette *active)
void BKE_gpencil_palette_setactive(bGPdata *gpd, bGPDpalette *active)
{
bGPDpalette *palette;
@ -1191,11 +1191,11 @@ void gpencil_palette_setactive(bGPdata *gpd, bGPDpalette *active)
/* set as active one */
active->flag |= PL_PALETTE_ACTIVE;
/* force color recalc */
gpencil_palette_change_strokes(gpd);
BKE_gpencil_palette_change_strokes(gpd);
}
/* delete the active gp-palette */
void gpencil_palette_delete(bGPdata *gpd, bGPDpalette *palette)
void BKE_gpencil_palette_delete(bGPdata *gpd, bGPDpalette *palette)
{
/* error checking */
if (ELEM(NULL, gpd, palette)) {
@ -1206,11 +1206,11 @@ void gpencil_palette_delete(bGPdata *gpd, bGPDpalette *palette)
free_gpencil_colors(palette);
BLI_freelinkN(&gpd->palettes, palette);
/* force color recalc */
gpencil_palette_change_strokes(gpd);
BKE_gpencil_palette_change_strokes(gpd);
}
/* Set all strokes to recalc the palette color */
void gpencil_palette_change_strokes(bGPdata *gpd)
void BKE_gpencil_palette_change_strokes(bGPdata *gpd)
{
bGPDlayer *gpl;
bGPDframe *gpf;
@ -1227,7 +1227,7 @@ void gpencil_palette_change_strokes(bGPdata *gpd)
/* get the active gp-palettecolor for editing */
bGPDpalettecolor *gpencil_palettecolor_getactive(bGPDpalette *palette)
bGPDpalettecolor *BKE_gpencil_palettecolor_getactive(bGPDpalette *palette)
{
bGPDpalettecolor *palcolor;
@ -1247,7 +1247,7 @@ bGPDpalettecolor *gpencil_palettecolor_getactive(bGPDpalette *palette)
return NULL;
}
/* get the gp-palettecolor looking for name */
bGPDpalettecolor *gpencil_palettecolor_getbyname(bGPDpalette *palette, char *name)
bGPDpalettecolor *BKE_gpencil_palettecolor_getbyname(bGPDpalette *palette, char *name)
{
/* error checking */
if (ELEM(NULL, palette, name)) {
@ -1258,7 +1258,7 @@ bGPDpalettecolor *gpencil_palettecolor_getbyname(bGPDpalette *palette, char *nam
}
/* Change color name in all strokes */
void gpencil_palettecolor_changename(bGPdata *gpd, char *oldname, const char *newname)
void BKE_gpencil_palettecolor_changename(bGPdata *gpd, char *oldname, const char *newname)
{
bGPDlayer *gpl;
bGPDframe *gpf;
@ -1277,7 +1277,7 @@ void gpencil_palettecolor_changename(bGPdata *gpd, char *oldname, const char *ne
}
/* Delete all strokes of the color */
void gpencil_palettecolor_delete_strokes(struct bGPdata *gpd, char *name)
void BKE_gpencil_palettecolor_delete_strokes(struct bGPdata *gpd, char *name)
{
bGPDlayer *gpl;
bGPDframe *gpf;
@ -1300,7 +1300,7 @@ void gpencil_palettecolor_delete_strokes(struct bGPdata *gpd, char *name)
}
/* set the active gp-palettecolor */
void gpencil_palettecolor_setactive(bGPDpalette *palette, bGPDpalettecolor *active)
void BKE_gpencil_palettecolor_setactive(bGPDpalette *palette, bGPDpalettecolor *active)
{
bGPDpalettecolor *palcolor;
@ -1319,7 +1319,7 @@ void gpencil_palettecolor_setactive(bGPDpalette *palette, bGPDpalettecolor *acti
}
/* delete the active gp-palettecolor */
void gpencil_palettecolor_delete(bGPDpalette *palette, bGPDpalettecolor *palcolor)
void BKE_gpencil_palettecolor_delete(bGPDpalette *palette, bGPDpalettecolor *palcolor)
{
/* error checking */
if (ELEM(NULL, palette, palcolor)) {

2
source/blender/blenkernel/intern/library.c
View File

@ -510,7 +510,7 @@ bool id_copy(Main *bmain, ID *id, ID **newid, bool test)
if (!test) *newid = (ID *)BKE_particlesettings_copy(bmain, (ParticleSettings *)id);
return true;
case ID_GD:
if (!test) *newid = (ID *)gpencil_data_duplicate(bmain, (bGPdata *)id, false);
if (!test) *newid = (ID *)BKE_gpencil_data_duplicate(bmain, (bGPdata *)id, false);
return true;
case ID_MC:
if (!test) *newid = (ID *)BKE_movieclip_copy(bmain, (MovieClip *)id);

6
source/blender/blenkernel/intern/scene.c
View File

@ -290,7 +290,7 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
/* duplicate Grease Pencil Drawing Brushes */
BLI_listbase_clear(&ts->gp_brushes);
for (bGPDbrush *brush = sce->toolsettings->gp_brushes.first; brush; brush = brush->next) {
bGPDbrush *newbrush = gpencil_brush_duplicate(brush);
bGPDbrush *newbrush = BKE_gpencil_brush_duplicate(brush);
BLI_addtail(&ts->gp_brushes, newbrush);
}
@ -342,7 +342,7 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
/* grease pencil */
if (scen->gpd) {
if (type == SCE_COPY_FULL) {
scen->gpd = gpencil_data_duplicate(bmain, scen->gpd, false);
scen->gpd = BKE_gpencil_data_duplicate(bmain, scen->gpd, false);
}
else if (type == SCE_COPY_EMPTY) {
scen->gpd = NULL;
@ -441,7 +441,7 @@ void BKE_scene_free(Scene *sce)
MEM_freeN(sce->toolsettings->uvsculpt);
}
/* free Grease Pencil Drawing Brushes */
free_gpencil_brushes(&sce->toolsettings->gp_brushes);
BKE_gpencil_free_brushes(&sce->toolsettings->gp_brushes);
BLI_freelistN(&sce->toolsettings->gp_brushes);
BKE_paint_free(&sce->toolsettings->imapaint.paint);

8
source/blender/blenloader/intern/versioning_270.c
View File

@ -1270,7 +1270,7 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *main)
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
ToolSettings *ts = scene->toolsettings;
if (BLI_listbase_is_empty(&ts->gp_brushes)) {
gpencil_brush_init_presets(ts);
BKE_gpencil_brush_init_presets(ts);
}
}
}
@ -1280,10 +1280,10 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *main)
for (bGPdata *gpd = main->gpencil.first; gpd; gpd = gpd->id.next) {
if (BLI_listbase_is_empty(&gpd->palettes)) {
/* create palette */
bGPDpalette *palette = gpencil_palette_addnew(gpd, "GP_Palette", true);
bGPDpalette *palette = BKE_gpencil_palette_addnew(gpd, "GP_Palette", true);
for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
/* create color using layer name */
bGPDpalettecolor *palcolor = gpencil_palettecolor_addnew(palette, gpl->info, true);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_addnew(palette, gpl->info, true);
if (palcolor != NULL) {
/* set color attributes */
copy_v4_v4(palcolor->color, gpl->color);
@ -1314,7 +1314,7 @@ void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *main)
}
/* set first color as active */
if (palette->colors.first)
gpencil_palettecolor_setactive(palette, palette->colors.first);
BKE_gpencil_palettecolor_setactive(palette, palette->colors.first);
}
}
}

2
source/blender/editors/animation/anim_channels_edit.c
View File

@ -1686,7 +1686,7 @@ static int animchannels_delete_exec(bContext *C, wmOperator *UNUSED(op))
bGPDlayer *gpl = (bGPDlayer *)ale->data;
/* try to delete the layer's data and the layer itself */
free_gpencil_frames(gpl);
BKE_gpencil_free_frames(gpl);
BLI_freelinkN(&gpd->layers, gpl);
break;
}

6
source/blender/editors/gpencil/drawgpencil.c
View File

@ -1359,7 +1359,7 @@ static void gp_draw_data_layers(
continue;
/* get frame to draw */
gpf = gpencil_layer_getframe(gpl, cfra, 0);
gpf = BKE_gpencil_layer_getframe(gpl, cfra, 0);
if (gpf == NULL)
continue;
@ -1533,7 +1533,7 @@ static void gp_draw_data_all(Scene *scene, bGPdata *gpd, int offsx, int offsy, i
if (gpd_source) {
ToolSettings *ts = scene->toolsettings;
bGPDbrush *brush = gpencil_brush_getactive(ts);
bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
if (brush != NULL) {
gp_draw_data(brush, ts->gp_sculpt.alpha, gpd_source,
offsx, offsy, winx, winy, cfra, dflag);
@ -1546,7 +1546,7 @@ static void gp_draw_data_all(Scene *scene, bGPdata *gpd, int offsx, int offsy, i
* if gpd_source == gpd, we don't have any object/track data and we can skip */
if (gpd_source == NULL || (gpd_source && gpd_source != gpd)) {
ToolSettings *ts = scene->toolsettings;
bGPDbrush *brush = gpencil_brush_getactive(ts);
bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
if (brush != NULL) {
gp_draw_data(brush, ts->gp_sculpt.alpha, gpd,
offsx, offsy, winx, winy, cfra, dflag);

12
source/blender/editors/gpencil/editaction_gpencil.c
View File

@ -253,7 +253,7 @@ bool ED_gplayer_frames_delete(bGPDlayer *gpl)
gpfn = gpf->next;
if (gpf->flag & GP_FRAME_SELECT)
changed |= gpencil_layer_delframe(gpl, gpf);
changed |= BKE_gpencil_layer_delframe(gpl, gpf);
}
return changed;
@ -277,7 +277,7 @@ void ED_gplayer_frames_duplicate(bGPDlayer *gpl)
bGPDframe *gpfd;
/* duplicate frame, and deselect self */
gpfd = gpencil_frame_duplicate(gpf);
gpfd = BKE_gpencil_frame_duplicate(gpf);
gpf->flag &= ~GP_FRAME_SELECT;
BLI_insertlinkafter(&gpl->frames, gpf, gpfd);
@ -323,7 +323,7 @@ static int gp_anim_copy_cfra = 0;
/* This function frees any MEM_calloc'ed copy/paste buffer data */
void ED_gpencil_anim_copybuf_free(void)
{
free_gpencil_layers(&gp_anim_copybuf);
BKE_gpencil_free_layers(&gp_anim_copybuf);
BLI_listbase_clear(&gp_anim_copybuf);
gp_anim_copy_firstframe = 999999999;
@ -364,7 +364,7 @@ bool ED_gpencil_anim_copybuf_copy(bAnimContext *ac)
/* if frame is selected, make duplicate it and its strokes */
if (gpf->flag & GP_FRAME_SELECT) {
/* make a copy of this frame */
bGPDframe *new_frame = gpencil_frame_duplicate(gpf);
bGPDframe *new_frame = BKE_gpencil_frame_duplicate(gpf);
BLI_addtail(&copied_frames, new_frame);
/* extend extents for keyframes encountered */
@ -475,7 +475,7 @@ bool ED_gpencil_anim_copybuf_paste(bAnimContext *ac, const short offset_mode)
gpfs->framenum += offset;
/* get frame to copy data into (if no frame returned, then just ignore) */
gpf = gpencil_layer_getframe(gpld, gpfs->framenum, 1);
gpf = BKE_gpencil_layer_getframe(gpld, gpfs->framenum, 1);
if (gpf) {
bGPDstroke *gps, *gpsn;
@ -498,7 +498,7 @@ bool ED_gpencil_anim_copybuf_paste(bAnimContext *ac, const short offset_mode)
/* if no strokes (i.e. new frame) added, free gpf */
if (BLI_listbase_is_empty(&gpf->strokes))
gpencil_layer_delframe(gpld, gpf);
BKE_gpencil_layer_delframe(gpld, gpf);
}
/* unapply offset from buffer-frame */

4
source/blender/editors/gpencil/gpencil_brush.c
View File

@ -841,7 +841,7 @@ static void gp_brush_clone_add(bContext *C, tGP_BrushEditData *gso)
Scene *scene = gso->scene;
bGPDlayer *gpl = CTX_data_active_gpencil_layer(C);
bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, true);
bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, CFRA, true);
bGPDstroke *gps;
float delta[3];
@ -1185,7 +1185,7 @@ static void gpsculpt_brush_init_stroke(tGP_BrushEditData *gso)
*/
// XXX: should this be allowed when framelock is enabled?
if (gpf->framenum != cfra) {
gpencil_frame_addcopy(gpl, cfra);
BKE_gpencil_frame_addcopy(gpl, cfra);
}
}
}

10
source/blender/editors/gpencil/gpencil_convert.c
View File

@ -1123,7 +1123,7 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
struct Main *bmain = CTX_data_main(C);
View3D *v3d = CTX_wm_view3d(C); /* may be NULL */
Scene *scene = CTX_data_scene(C);
bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, 0);
bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0);
bGPDstroke *gps, *prev_gps = NULL;
Object *ob;
Curve *cu;
@ -1235,7 +1235,7 @@ static bool gp_convert_check_has_valid_timing(bContext *C, bGPDlayer *gpl, wmOpe
int i;
bool valid = true;
if (!gpl || !(gpf = gpencil_layer_getframe(gpl, CFRA, 0)) || !(gps = gpf->strokes.first))
if (!gpl || !(gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0)) || !(gps = gpf->strokes.first))
return false;
do {
@ -1292,8 +1292,8 @@ static int gp_convert_poll(bContext *C)
* and if we are not in edit mode!
*/
return ((sa && sa->spacetype == SPACE_VIEW3D) &&
(gpl = gpencil_layer_getactive(gpd)) &&
(gpf = gpencil_layer_getframe(gpl, CFRA, 0)) &&
(gpl = BKE_gpencil_layer_getactive(gpd)) &&
(gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0)) &&
(gpf->strokes.first) &&
(scene->obedit == NULL));
}
@ -1302,7 +1302,7 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
{
PropertyRNA *prop = RNA_struct_find_property(op->ptr, "use_timing_data");
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
Scene *scene = CTX_data_scene(C);
const int mode = RNA_enum_get(op->ptr, "type");
const bool norm_weights = RNA_boolean_get(op->ptr, "use_normalize_weights");

150
source/blender/editors/gpencil/gpencil_data.c
View File

@ -97,7 +97,7 @@ static int gp_data_add_exec(bContext *C, wmOperator *op)
bGPdata *gpd = (*gpd_ptr);
id_us_min(&gpd->id);
*gpd_ptr = gpencil_data_addnew(DATA_("GPencil"));
*gpd_ptr = BKE_gpencil_data_addnew(DATA_("GPencil"));
}
/* notifiers */
@ -184,10 +184,10 @@ static int gp_layer_add_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
if (*gpd_ptr == NULL)
*gpd_ptr = gpencil_data_addnew(DATA_("GPencil"));
*gpd_ptr = BKE_gpencil_data_addnew(DATA_("GPencil"));
/* add new layer now */
gpencil_layer_addnew(*gpd_ptr, DATA_("GP_Layer"), true);
BKE_gpencil_layer_addnew(*gpd_ptr, DATA_("GP_Layer"), true);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -214,7 +214,7 @@ void GPENCIL_OT_layer_add(wmOperatorType *ot)
static int gp_layer_remove_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
/* sanity checks */
if (ELEM(NULL, gpd, gpl))
@ -230,12 +230,12 @@ static int gp_layer_remove_exec(bContext *C, wmOperator *op)
* - if this is the only layer, this naturally becomes NULL
*/
if (gpl->prev)
gpencil_layer_setactive(gpd, gpl->prev);
BKE_gpencil_layer_setactive(gpd, gpl->prev);
else
gpencil_layer_setactive(gpd, gpl->next);
BKE_gpencil_layer_setactive(gpd, gpl->next);
/* delete the layer now... */
gpencil_layer_delete(gpd, gpl);
BKE_gpencil_layer_delete(gpd, gpl);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -267,7 +267,7 @@ enum {
static int gp_layer_move_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
int direction = RNA_enum_get(op->ptr, "type");
@ -321,7 +321,7 @@ void GPENCIL_OT_layer_move(wmOperatorType *ot)
static int gp_layer_copy_exec(bContext *C, wmOperator *UNUSED(op))
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
bGPDlayer *new_layer;
/* sanity checks */
@ -329,12 +329,12 @@ static int gp_layer_copy_exec(bContext *C, wmOperator *UNUSED(op))
return OPERATOR_CANCELLED;
/* make copy of layer, and add it immediately after the existing layer */
new_layer = gpencil_layer_duplicate(gpl);
new_layer = BKE_gpencil_layer_duplicate(gpl);
BLI_insertlinkafter(&gpd->layers, gpl, new_layer);
/* ensure new layer has a unique name, and is now the active layer */
BLI_uniquename(&gpd->layers, new_layer, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(new_layer->info));
gpencil_layer_setactive(gpd, new_layer);
BKE_gpencil_layer_setactive(gpd, new_layer);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -362,7 +362,7 @@ void GPENCIL_OT_layer_duplicate(wmOperatorType *ot)
static int gp_hide_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *layer = gpencil_layer_getactive(gpd);
bGPDlayer *layer = BKE_gpencil_layer_getactive(gpd);
bool unselected = RNA_boolean_get(op->ptr, "unselected");
/* sanity checks */
@ -530,7 +530,7 @@ void GPENCIL_OT_unlock_all(wmOperatorType *ot)
static int gp_isolate_layer_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *layer = gpencil_layer_getactive(gpd);
bGPDlayer *layer = BKE_gpencil_layer_getactive(gpd);
bGPDlayer *gpl;
int flags = GP_LAYER_LOCKED;
bool isolate = false;
@ -606,7 +606,7 @@ void GPENCIL_OT_layer_isolate(wmOperatorType *ot)
static int gp_merge_layer_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl_current = gpencil_layer_getactive(gpd);
bGPDlayer *gpl_current = BKE_gpencil_layer_getactive(gpd);
bGPDlayer *gpl_next = gpl_current->next;
if (ELEM(NULL, gpd, gpl_current, gpl_next)) {
@ -626,13 +626,13 @@ static int gp_merge_layer_exec(bContext *C, wmOperator *op)
bGPDframe *frame = BLI_ghash_lookup(gh_frames_cur, SET_INT_IN_POINTER(gpf->framenum));
if (!frame) {
/* nothing found, create new */
frame = gpencil_frame_addnew(gpl_current, gpf->framenum);
frame = BKE_gpencil_frame_addnew(gpl_current, gpf->framenum);
}
/* add to tail all strokes */
BLI_movelisttolist(&frame->strokes, &gpf->strokes);
}
/* Now delete next layer */
gpencil_layer_delete(gpd, gpl_next);
BKE_gpencil_layer_delete(gpd, gpl_next);
BLI_ghash_free(gh_frames_cur, NULL, NULL);
/* notifiers */
@ -681,7 +681,7 @@ static int gp_layer_change_exec(bContext *C, wmOperator *op)
/* Get layer or create new one */
if (layer_num == -1) {
/* Create layer */
gpl = gpencil_layer_addnew(gpd, DATA_("GP_Layer"), true);
gpl = BKE_gpencil_layer_addnew(gpd, DATA_("GP_Layer"), true);
}
else {
/* Try to get layer */
@ -694,7 +694,7 @@ static int gp_layer_change_exec(bContext *C, wmOperator *op)
}
/* Set active layer */
gpencil_layer_setactive(gpd, gpl);
BKE_gpencil_layer_setactive(gpd, gpl);
/* updates */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -736,7 +736,7 @@ enum {
static int gp_stroke_arrange_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
bGPDstroke *gps;
/* sanity checks */
@ -861,8 +861,8 @@ static int gp_stroke_change_color_exec(bContext *C, wmOperator *UNUSED(op))
return OPERATOR_CANCELLED;
}
palette = gpencil_palette_getactive(gpd);
color = gpencil_palettecolor_getactive(palette);
palette = BKE_gpencil_palette_getactive(gpd);
color = BKE_gpencil_palettecolor_getactive(palette);
if (ELEM(NULL, palette, color)) {
return OPERATOR_CANCELLED;
}
@ -919,7 +919,7 @@ static int gp_stroke_lock_color_exec(bContext *C, wmOperator *UNUSED(op))
if (ELEM(NULL, gpd))
return OPERATOR_CANCELLED;
palette = gpencil_palette_getactive(gpd);
palette = BKE_gpencil_palette_getactive(gpd);
if (ELEM(NULL, palette))
return OPERATOR_CANCELLED;
@ -970,7 +970,7 @@ void GPENCIL_OT_stroke_lock_color(wmOperatorType *ot)
static int gp_stroke_apply_thickness_exec(bContext *C, wmOperator *UNUSED(op))
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
/* sanity checks */
if (ELEM(NULL, gpd, gpl, gpl->frames.first))
@ -1213,10 +1213,10 @@ enum {
static int gp_stroke_join_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *activegpl = gpencil_layer_getactive(gpd);
bGPDlayer *activegpl = BKE_gpencil_layer_getactive(gpd);
bGPDstroke *gps, *gpsn;
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
bGPDframe *gpf_a = NULL;
bGPDstroke *stroke_a = NULL;
@ -1283,12 +1283,12 @@ static int gp_stroke_join_exec(bContext *C, wmOperator *op)
if (stroke_a) {
BLI_insertlinkbefore(&gpf_a->strokes, stroke_a, new_stroke);
BLI_remlink(&gpf->strokes, stroke_a);
free_gpencil_stroke(stroke_a);
BKE_gpencil_free_stroke(stroke_a);
stroke_a = NULL;
}
if (stroke_b) {
BLI_remlink(&gpf->strokes, stroke_b);
free_gpencil_stroke(stroke_b);
BKE_gpencil_free_stroke(stroke_b);
stroke_b = NULL;
}
}
@ -1302,7 +1302,7 @@ static int gp_stroke_join_exec(bContext *C, wmOperator *op)
if (new_stroke) {
/* Add a new frame if needed */
if (activegpl->actframe == NULL)
activegpl->actframe = gpencil_frame_addnew(activegpl, gpf_a->framenum);
activegpl->actframe = BKE_gpencil_frame_addnew(activegpl, gpf_a->framenum);
BLI_addtail(&activegpl->actframe->strokes, new_stroke);
}
@ -1405,7 +1405,7 @@ static int gp_brush_add_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
/* add new brush now */
gpencil_brush_addnew(ts, DATA_("GP_Brush"), true);
BKE_gpencil_brush_addnew(ts, DATA_("GP_Brush"), true);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1432,7 +1432,7 @@ void GPENCIL_OT_brush_add(wmOperatorType *ot)
static int gp_brush_remove_exec(bContext *C, wmOperator *op)
{
ToolSettings *ts = CTX_data_tool_settings(C);
bGPDbrush *brush = gpencil_brush_getactive(ts);
bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
/* sanity checks */
if (ELEM(NULL, ts, brush))
@ -1449,12 +1449,12 @@ static int gp_brush_remove_exec(bContext *C, wmOperator *op)
* - if this is the only brush, this naturally becomes NULL
*/
if (brush->prev)
gpencil_brush_setactive(ts, brush->prev);
BKE_gpencil_brush_setactive(ts, brush->prev);
else
gpencil_brush_setactive(ts, brush->next);
BKE_gpencil_brush_setactive(ts, brush->next);
/* delete the brush now... */
gpencil_brush_delete(ts, brush);
BKE_gpencil_brush_delete(ts, brush);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1501,7 +1501,7 @@ static int gp_brush_change_exec(bContext *C, wmOperator *op)
/* Get brush or create new one */
if (brush_num == -1) {
/* Create brush */
brush = gpencil_brush_addnew(ts, DATA_("GP_Brush"), true);
brush = BKE_gpencil_brush_addnew(ts, DATA_("GP_Brush"), true);
}
else {
/* Try to get brush */
@ -1514,7 +1514,7 @@ static int gp_brush_change_exec(bContext *C, wmOperator *op)
}
/* Set active brush */
gpencil_brush_setactive(ts, brush);
BKE_gpencil_brush_setactive(ts, brush);
/* updates */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1552,7 +1552,7 @@ enum {
static int gp_brush_move_exec(bContext *C, wmOperator *op)
{
ToolSettings *ts = CTX_data_tool_settings(C);
bGPDbrush *brush = gpencil_brush_getactive(ts);
bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
int direction = RNA_enum_get(op->ptr, "type");
@ -1610,7 +1610,7 @@ void GPENCIL_OT_brush_move(wmOperatorType *ot)
static int gp_brush_presets_create_exec(bContext *C, wmOperator *UNUSED(op))
{
ToolSettings *ts = CTX_data_tool_settings(C);
gpencil_brush_init_presets(ts);
BKE_gpencil_brush_init_presets(ts);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1645,7 +1645,7 @@ static int gp_brush_copy_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
bGPDbrush *brush = gpencil_brush_getactive(ts);
bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
bGPDbrush *newbrush;
/* sanity checks */
@ -1653,7 +1653,7 @@ static int gp_brush_copy_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
/* create a brush and duplicate data */
newbrush = gpencil_brush_addnew(ts, brush->info, true);
newbrush = BKE_gpencil_brush_addnew(ts, brush->info, true);
newbrush->thickness = brush->thickness;
newbrush->draw_smoothfac = brush->draw_smoothfac;
newbrush->draw_smoothlvl = brush->draw_smoothlvl;
@ -1677,7 +1677,7 @@ static int gp_brush_copy_exec(bContext *C, wmOperator *op)
newbrush->cur_strength = curvemapping_copy(brush->cur_strength);
newbrush->cur_jitter = curvemapping_copy(brush->cur_jitter);
gpencil_brush_setactive(ts, newbrush);
BKE_gpencil_brush_setactive(ts, newbrush);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1718,7 +1718,7 @@ static int gp_brush_select_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
gpencil_brush_setactive(ts, brush);
BKE_gpencil_brush_setactive(ts, brush);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1760,10 +1760,10 @@ static int gp_palette_add_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
if (*gpd_ptr == NULL)
*gpd_ptr = gpencil_data_addnew(DATA_("GPencil"));
*gpd_ptr = BKE_gpencil_data_addnew(DATA_("GPencil"));
/* add new palette now */
gpencil_palette_addnew(*gpd_ptr, DATA_("GP_Palette"), true);
BKE_gpencil_palette_addnew(*gpd_ptr, DATA_("GP_Palette"), true);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1790,7 +1790,7 @@ void GPENCIL_OT_palette_add(wmOperatorType *ot)
static int gp_palette_remove_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
/* sanity checks */
if (ELEM(NULL, gpd, palette))
@ -1807,12 +1807,12 @@ static int gp_palette_remove_exec(bContext *C, wmOperator *op)
* - if this is the only palette, this naturally becomes NULL
*/
if (palette->prev)
gpencil_palette_setactive(gpd, palette->prev);
BKE_gpencil_palette_setactive(gpd, palette->prev);
else
gpencil_palette_setactive(gpd, palette->next);
BKE_gpencil_palette_setactive(gpd, palette->next);
/* delete the palette now... */
gpencil_palette_delete(gpd, palette);
BKE_gpencil_palette_delete(gpd, palette);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1859,7 +1859,7 @@ static int gp_palette_change_exec(bContext *C, wmOperator *op)
/* Get palette or create new one */
if (palette_num == -1) {
/* Create palette */
palette = gpencil_palette_addnew(gpd, DATA_("GP_Palette"), true);
palette = BKE_gpencil_palette_addnew(gpd, DATA_("GP_Palette"), true);
}
else {
/* Try to get palette */
@ -1872,7 +1872,7 @@ static int gp_palette_change_exec(bContext *C, wmOperator *op)
}
/* Set active palette */
gpencil_palette_setactive(gpd, palette);
BKE_gpencil_palette_setactive(gpd, palette);
/* updates */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -1911,7 +1911,7 @@ static int gp_palette_lock_layer_exec(bContext *C, wmOperator *UNUSED(op))
if (ELEM(NULL, gpd))
return OPERATOR_CANCELLED;
palette = gpencil_palette_getactive(gpd);
palette = BKE_gpencil_palette_getactive(gpd);
if (ELEM(NULL, palette))
return OPERATOR_CANCELLED;
@ -1972,15 +1972,15 @@ static int gp_palettecolor_add_exec(bContext *C, wmOperator *op)
return OPERATOR_CANCELLED;
}
if (*gpd_ptr == NULL)
*gpd_ptr = gpencil_data_addnew(DATA_("GPencil"));
*gpd_ptr = BKE_gpencil_data_addnew(DATA_("GPencil"));
/* verify palette */
bGPDpalette *palette = gpencil_palette_getactive(*gpd_ptr);
bGPDpalette *palette = BKE_gpencil_palette_getactive(*gpd_ptr);
if (palette == NULL)
palette = gpencil_palette_addnew(*gpd_ptr, DATA_("GP_Palette"), true);
palette = BKE_gpencil_palette_addnew(*gpd_ptr, DATA_("GP_Palette"), true);
/* add new palette color now */
gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
BKE_gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -2007,8 +2007,8 @@ void GPENCIL_OT_palettecolor_add(wmOperatorType *ot)
static int gp_palettecolor_remove_exec(bContext *C, wmOperator *UNUSED(op))
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalettecolor *color = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *color = BKE_gpencil_palettecolor_getactive(palette);
/* sanity checks */
if (ELEM(NULL, gpd, palette, color))
@ -2019,15 +2019,15 @@ static int gp_palettecolor_remove_exec(bContext *C, wmOperator *UNUSED(op))
* - if this is the only color, this naturally becomes NULL
*/
if (color->prev)
gpencil_palettecolor_setactive(palette, color->prev);
BKE_gpencil_palettecolor_setactive(palette, color->prev);
else
gpencil_palettecolor_setactive(palette, color->next);
BKE_gpencil_palettecolor_setactive(palette, color->next);
/* delete the strokes */
gpencil_palettecolor_delete_strokes(gpd, color->info);
BKE_gpencil_palettecolor_delete_strokes(gpd, color->info);
/* delete the palette color now... */
gpencil_palettecolor_delete(palette, color);
BKE_gpencil_palettecolor_delete(palette, color);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -2054,8 +2054,8 @@ void GPENCIL_OT_palettecolor_remove(wmOperatorType *ot)
static int gp_isolate_palettecolor_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalettecolor *active_color = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *active_color = BKE_gpencil_palettecolor_getactive(palette);
bGPDpalettecolor *palcolor;
int flags = PC_COLOR_LOCKED;
@ -2131,8 +2131,8 @@ void GPENCIL_OT_palettecolor_isolate(wmOperatorType *ot)
static int gp_palettecolor_hide_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
bool unselected = RNA_boolean_get(op->ptr, "unselected");
@ -2190,7 +2190,7 @@ static int gp_palettecolor_reveal_poll(bContext *C)
static int gp_palettecolor_reveal_exec(bContext *C, wmOperator *UNUSED(op))
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor;
/* sanity checks */
@ -2228,7 +2228,7 @@ void GPENCIL_OT_palettecolor_reveal(wmOperatorType *ot)
static int gp_palettecolor_lock_all_exec(bContext *C, wmOperator *UNUSED(op))
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor;
/* sanity checks */
@ -2266,7 +2266,7 @@ void GPENCIL_OT_palettecolor_lock_all(wmOperatorType *ot)
static int gp_palettecolor_unlock_all_exec(bContext *C, wmOperator *UNUSED(op))
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor;
/* sanity checks */
@ -2309,8 +2309,8 @@ enum {
static int gp_palettecolor_move_exec(bContext *C, wmOperator *op)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
int direction = RNA_enum_get(op->ptr, "direction");
@ -2367,8 +2367,8 @@ void GPENCIL_OT_palettecolor_move(wmOperatorType *ot)
static int gp_palettecolor_select_exec(bContext *C, wmOperator *UNUSED(op))
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
/* sanity checks */
if (ELEM(NULL, gpd, palette, palcolor))
@ -2426,8 +2426,8 @@ void GPENCIL_OT_palettecolor_select(wmOperatorType *ot)
static int gp_palettecolor_copy_exec(bContext *C, wmOperator *UNUSED(op))
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
bGPDpalettecolor *newcolor;
/* sanity checks */
@ -2435,7 +2435,7 @@ static int gp_palettecolor_copy_exec(bContext *C, wmOperator *UNUSED(op))
return OPERATOR_CANCELLED;
/* create a new color and duplicate data */
newcolor = gpencil_palettecolor_addnew(palette, palcolor->info, true);
newcolor = BKE_gpencil_palettecolor_addnew(palette, palcolor->info, true);
copy_v4_v4(newcolor->color, palcolor->color);
copy_v4_v4(newcolor->fill, palcolor->fill);
newcolor->flag = palcolor->flag;

20
source/blender/editors/gpencil/gpencil_edit.c
View File

@ -462,7 +462,7 @@ static int gp_strokes_paste_exec(bContext *C, wmOperator *op)
}
else if (gpl == NULL) {
/* no active layer - let's just create one */
gpl = gpencil_layer_addnew(gpd, DATA_("GP_Layer"), true);
gpl = BKE_gpencil_layer_addnew(gpd, DATA_("GP_Layer"), true);
}
else if ((gpencil_layer_is_editable(gpl) == false) && (type == GP_COPY_MERGE)) {
BKE_report(op->reports, RPT_ERROR, "Can not paste strokes when active layer is hidden or locked");
@ -525,7 +525,7 @@ static int gp_strokes_paste_exec(bContext *C, wmOperator *op)
gpl = CTX_data_active_gpencil_layer(C);
}
}
gpf = gpencil_layer_getframe(gpl, CFRA, true);
gpf = BKE_gpencil_layer_getframe(gpl, CFRA, true);
if (gpf) {
bGPDstroke *new_stroke = MEM_dupallocN(gps);
new_stroke->tmp_layerinfo[0] = '\0';
@ -597,7 +597,7 @@ static int gp_move_to_layer_exec(bContext *C, wmOperator *op)
/* Get layer or create new one */
if (layer_num == -1) {
/* Create layer */
target_layer = gpencil_layer_addnew(gpd, DATA_("GP_Layer"), true);
target_layer = BKE_gpencil_layer_addnew(gpd, DATA_("GP_Layer"), true);
}
else {
/* Try to get layer */
@ -642,7 +642,7 @@ 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 = gpencil_layer_getframe(target_layer, CFRA, true);
bGPDframe *gpf = BKE_gpencil_layer_getframe(target_layer, CFRA, true);
BLI_movelisttolist(&gpf->strokes, &strokes);
BLI_assert((strokes.first == strokes.last) && (strokes.first == NULL));
@ -679,7 +679,7 @@ void GPENCIL_OT_move_to_layer(wmOperatorType *ot)
static int gp_actframe_delete_poll(bContext *C)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
/* only if there's an active layer with an active frame */
return (gpl && gpl->actframe);
@ -690,8 +690,8 @@ 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 = gpencil_layer_getactive(gpd);
bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, 0);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0);
/* if there's no existing Grease-Pencil data there, add some */
if (gpd == NULL) {
@ -704,7 +704,7 @@ static int gp_actframe_delete_exec(bContext *C, wmOperator *op)
}
/* delete it... */
gpencil_layer_delframe(gpl, gpf);
BKE_gpencil_layer_delframe(gpl, gpf);
/* notifiers */
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -746,13 +746,13 @@ static int gp_actframe_delete_all_exec(bContext *C, wmOperator *op)
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 = gpencil_layer_getframe(gpl, CFRA, 0);
bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0);
if (gpf == NULL)
continue;
/* delete it... */
gpencil_layer_delframe(gpl, gpf);
BKE_gpencil_layer_delframe(gpl, gpf);
/* we successfully modified something */
success = true;

32
source/blender/editors/gpencil/gpencil_paint.c
View File

@ -544,7 +544,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure,
}
else if (p->paintmode == GP_PAINTMODE_DRAW_POLY) {
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
/* get pointer to destination point */
pt = (tGPspoint *)(gpd->sbuffer);
@ -920,8 +920,8 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
MEM_freeN(depth_arr);
}
/* Save palette color */
bGPDpalette *palette = gpencil_palette_getactive(p->gpd);
bGPDpalettecolor *palcolor = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(p->gpd);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
gps->palcolor = palcolor;
strcpy(gps->colorname, palcolor->info);
@ -1221,7 +1221,7 @@ static bGPDpalettecolor *gp_create_new_color(bGPDpalette *palette)
{
bGPDpalettecolor *palcolor;
palcolor = gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
palcolor = BKE_gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
return palcolor;
}
@ -1234,12 +1234,12 @@ static void gp_init_drawing_brush(ToolSettings *ts, tGPsdata *p)
/* if not exist, create a new one */
if (BLI_listbase_is_empty(&ts->gp_brushes)) {
/* create new brushes */
gpencil_brush_init_presets(ts);
brush = gpencil_brush_getactive(ts);
BKE_gpencil_brush_init_presets(ts);
brush = BKE_gpencil_brush_getactive(ts);
}
else {
/* Use the current */
brush = gpencil_brush_getactive(ts);
brush = BKE_gpencil_brush_getactive(ts);
}
/* be sure curves are initializated */
curvemapping_initialize(brush->cur_sensitivity);
@ -1263,23 +1263,23 @@ static void gp_init_palette(tGPsdata *p)
/* if not exist, create a new palette */
if (BLI_listbase_is_empty(&gpd->palettes)) {
/* create new palette */
palette = gpencil_palette_addnew(gpd, DATA_("GP_Palette"), true);
palette = BKE_gpencil_palette_addnew(gpd, DATA_("GP_Palette"), true);
/* now create a default color */
palcolor = gp_create_new_color(palette);
}
else {
/* Use the current palette and color */
palette = gpencil_palette_getactive(gpd);
palette = BKE_gpencil_palette_getactive(gpd);
/* the palette needs one color */
if (BLI_listbase_is_empty(&palette->colors)) {
palcolor = gp_create_new_color(palette);
}
else {
palcolor = gpencil_palettecolor_getactive(palette);
palcolor = BKE_gpencil_palettecolor_getactive(palette);
}
/* in some situations can be null, so use first */
if (palcolor == NULL) {
gpencil_palettecolor_setactive(palette, palette->colors.first);
BKE_gpencil_palettecolor_setactive(palette, palette->colors.first);
palcolor = palette->colors.first;
}
}
@ -1439,7 +1439,7 @@ static bool gp_session_initdata(bContext *C, tGPsdata *p)
else {
/* if no existing GPencil block exists, add one */
if (*gpd_ptr == NULL)
*gpd_ptr = gpencil_data_addnew("GPencil");
*gpd_ptr = BKE_gpencil_data_addnew("GPencil");
p->gpd = *gpd_ptr;
}
@ -1514,9 +1514,9 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode)
ToolSettings *ts = scene->toolsettings;
/* get active layer (or add a new one if non-existent) */
p->gpl = gpencil_layer_getactive(p->gpd);
p->gpl = BKE_gpencil_layer_getactive(p->gpd);
if (p->gpl == NULL) {
p->gpl = gpencil_layer_addnew(p->gpd, "GP_Layer", true);
p->gpl = BKE_gpencil_layer_addnew(p->gpd, "GP_Layer", true);
if (p->custom_color[3])
copy_v3_v3(p->gpl->color, p->custom_color);
@ -1544,7 +1544,7 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode)
/* Add a new frame if needed (and based off the active frame,
* as we need some existing strokes to erase)
*/
gpl->actframe = gpencil_layer_getframe(gpl, CFRA, GP_GETFRAME_ADD_COPY);
gpl->actframe = BKE_gpencil_layer_getframe(gpl, CFRA, GP_GETFRAME_ADD_COPY);
/* XXX: we omit GP_FRAME_PAINT here for now,
* as it is only really useful for doing
@ -1580,7 +1580,7 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode)
else
add_frame_mode = GP_GETFRAME_ADD_NEW;
p->gpf = gpencil_layer_getframe(p->gpl, CFRA, add_frame_mode);
p->gpf = BKE_gpencil_layer_getframe(p->gpl, CFRA, add_frame_mode);
if (p->gpf == NULL) {
p->status = GP_STATUS_ERROR;

10
source/blender/editors/gpencil/gpencil_select.c
View File

@ -266,7 +266,7 @@ static void gp_select_same_layer(bContext *C)
CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)
{
bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, 0);
bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0);
bGPDstroke *gps;
bool found = false;
@ -709,7 +709,7 @@ static bool gp_stroke_do_circle_sel(
}
/* Ensure that stroke selection is in sync with its points */
gpencil_stroke_sync_selection(gps);
BKE_gpencil_stroke_sync_selection(gps);
}
return changed;
@ -871,7 +871,7 @@ static int gpencil_border_select_exec(bContext *C, wmOperator *op)
}
/* Ensure that stroke selection is in sync with its points */
gpencil_stroke_sync_selection(gps);
BKE_gpencil_stroke_sync_selection(gps);
}
GP_EDITABLE_STROKES_END;
@ -981,7 +981,7 @@ static int gpencil_lasso_select_exec(bContext *C, wmOperator *op)
}
/* Ensure that stroke selection is in sync with its points */
gpencil_stroke_sync_selection(gps);
BKE_gpencil_stroke_sync_selection(gps);
}
GP_EDITABLE_STROKES_END;
@ -1152,7 +1152,7 @@ static int gpencil_select_exec(bContext *C, wmOperator *op)
hit_point->flag &= ~GP_SPOINT_SELECT;
/* ensure that stroke is selected correctly */
gpencil_stroke_sync_selection(hit_stroke);
BKE_gpencil_stroke_sync_selection(hit_stroke);
}
}

6
source/blender/editors/gpencil/gpencil_undo.c
View File

@ -100,14 +100,14 @@ int ED_undo_gpencil_step(bContext *C, int step, const char *name)
bGPdata *gpd = *gpd_ptr;
bGPDlayer *gpl, *gpld;
free_gpencil_layers(&gpd->layers);
BKE_gpencil_free_layers(&gpd->layers);
/* copy layers */
BLI_listbase_clear(&gpd->layers);
for (gpl = new_gpd->layers.first; gpl; gpl = gpl->next) {
/* make a copy of source layer and its data */
gpld = gpencil_layer_duplicate(gpl);
gpld = BKE_gpencil_layer_duplicate(gpl);
BLI_addtail(&gpd->layers, gpld);
}
}
@ -153,7 +153,7 @@ void gpencil_undo_push(bGPdata *gpd)
/* create new undo node */
undo_node = MEM_callocN(sizeof(bGPundonode), "gpencil undo node");
undo_node->gpd = gpencil_data_duplicate(G.main, gpd, true);
undo_node->gpd = BKE_gpencil_data_duplicate(G.main, gpd, true);
cur_node = undo_node;

24
source/blender/editors/gpencil/gpencil_utils.c
View File

@ -225,7 +225,7 @@ bool ED_gpencil_has_keyframe_v3d(Scene *scene, Object *ob, int cfra)
/* just check both for now... */
// XXX: this could get confusing (e.g. if only on the object, but other places don't show this)
if (scene->gpd) {
bGPDlayer *gpl = gpencil_layer_getactive(scene->gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(scene->gpd);
if (gpl) {
if (gpl->actframe) {
// XXX: assumes that frame has been fetched already
@ -239,7 +239,7 @@ bool ED_gpencil_has_keyframe_v3d(Scene *scene, Object *ob, int cfra)
}
if (ob && ob->gpd) {
bGPDlayer *gpl = gpencil_layer_getactive(ob->gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(ob->gpd);
if (gpl) {
if (gpl->actframe) {
// XXX: assumes that frame has been fetched already
@ -269,7 +269,7 @@ int gp_add_poll(bContext *C)
int gp_active_layer_poll(bContext *C)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
return (gpl != NULL);
}
@ -278,7 +278,7 @@ int gp_active_layer_poll(bContext *C)
int gp_active_brush_poll(bContext *C)
{
ToolSettings *ts = CTX_data_tool_settings(C);
bGPDbrush *brush = gpencil_brush_getactive(ts);
bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
return (brush != NULL);
}
@ -287,7 +287,7 @@ int gp_active_brush_poll(bContext *C)
int gp_active_palette_poll(bContext *C)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
return (palette != NULL);
}
@ -296,8 +296,8 @@ int gp_active_palette_poll(bContext *C)
int gp_active_palettecolor_poll(bContext *C)
{
bGPdata *gpd = ED_gpencil_data_get_active(C);
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = gpencil_palettecolor_getactive(palette);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
return (palcolor != NULL);
}
@ -470,20 +470,20 @@ bGPDpalettecolor *ED_gpencil_stroke_getcolor(bGPdata *gpd, bGPDstroke *gps)
return gps->palcolor;
/* get palette */
palette = gpencil_palette_getactive(gpd);
palette = BKE_gpencil_palette_getactive(gpd);
if (palette == NULL) {
palette = gpencil_palette_addnew(gpd, DATA_("GP_Palette"), true);
palette = BKE_gpencil_palette_addnew(gpd, DATA_("GP_Palette"), true);
}
/* get color */
palcolor = gpencil_palettecolor_getbyname(palette, gps->colorname);
palcolor = BKE_gpencil_palettecolor_getbyname(palette, gps->colorname);
if (palcolor == NULL) {
if (gps->palcolor == NULL) {
palcolor = gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
palcolor = BKE_gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
/* set to a different color */
ARRAY_SET_ITEMS(palcolor->color, 1.0f, 0.0f, 1.0f, 0.9f);
}
else {
palcolor = gpencil_palettecolor_addnew(palette, gps->colorname, true);
palcolor = BKE_gpencil_palettecolor_addnew(palette, gps->colorname, true);
/* set old color and attributes */
bGPDpalettecolor *gpscolor = gps->palcolor;
copy_v4_v4(palcolor->color, gpscolor->color);

12
source/blender/editors/screen/screen_context.c
View File

@ -467,7 +467,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, scene, sa, obact);
if (gpd) {
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
if (gpl) {
CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilLayer, gpl);
@ -480,7 +480,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, scene, sa, obact);
if (gpd) {
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
if (palette) {
CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilPalette, palette);
@ -493,10 +493,10 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, scene, sa, obact);
if (gpd) {
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
if (palette) {
bGPDpalettecolor *palcolor = gpencil_palettecolor_getactive(palette);
bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
if (palcolor) {
CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilPaletteColor, palcolor);
return 1;
@ -506,7 +506,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
}
else if (CTX_data_equals(member, "active_gpencil_brush")) {
/* XXX: see comment for gpencil_data case... */
bGPDbrush *brush = gpencil_brush_getactive(scene->toolsettings);
bGPDbrush *brush = BKE_gpencil_brush_getactive(scene->toolsettings);
if (brush) {
CTX_data_pointer_set(result, NULL, &RNA_GPencilBrush, brush);
@ -518,7 +518,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, scene, sa, obact);
if (gpd) {
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
if (gpl) {
CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilLayer, gpl->actframe);

2
source/blender/editors/space_action/action_edit.c
View File

@ -750,7 +750,7 @@ static void insert_gpencil_keys(bAnimContext *ac, short mode)
/* insert gp frames */
for (ale = anim_data.first; ale; ale = ale->next) {
bGPDlayer *gpl = (bGPDlayer *)ale->data;
gpencil_layer_getframe(gpl, CFRA, add_frame_mode);
BKE_gpencil_layer_getframe(gpl, CFRA, add_frame_mode);
}
ANIM_animdata_update(ac, &anim_data);

10
source/blender/editors/space_view3d/view3d_ruler.c
View File

@ -302,18 +302,18 @@ static bool view3d_ruler_to_gpencil(bContext *C, RulerInfo *ruler_info)
bool changed = false;
if (scene->gpd == NULL) {
scene->gpd = gpencil_data_addnew("GPencil");
scene->gpd = BKE_gpencil_data_addnew("GPencil");
}
gpl = BLI_findstring(&scene->gpd->layers, ruler_name, offsetof(bGPDlayer, info));
if (gpl == NULL) {
gpl = gpencil_layer_addnew(scene->gpd, ruler_name, false);
gpl = BKE_gpencil_layer_addnew(scene->gpd, ruler_name, false);
gpl->thickness = 1;
gpl->flag |= GP_LAYER_HIDE;
}
gpf = gpencil_layer_getframe(gpl, CFRA, true);
free_gpencil_strokes(gpf);
gpf = BKE_gpencil_layer_getframe(gpl, CFRA, true);
BKE_gpencil_free_strokes(gpf);
for (ruler_item = ruler_info->items.first; ruler_item; ruler_item = ruler_item->next) {
bGPDspoint *pt;
@ -360,7 +360,7 @@ static bool view3d_ruler_from_gpencil(bContext *C, RulerInfo *ruler_info)
gpl = BLI_findstring(&scene->gpd->layers, ruler_name, offsetof(bGPDlayer, info));
if (gpl) {
bGPDframe *gpf;
gpf = gpencil_layer_getframe(gpl, CFRA, false);
gpf = BKE_gpencil_layer_getframe(gpl, CFRA, false);
if (gpf) {
bGPDstroke *gps;
for (gps = gpf->strokes.first; gps; gps = gps->next) {

4
source/blender/editors/transform/transform_conversions.c
View File

@ -3292,7 +3292,7 @@ static void posttrans_gpd_clean(bGPdata *gpd)
for (gpf = gpl->frames.first; gpf; gpf = gpfn) {
gpfn = gpf->next;
if (gpfn && gpf->framenum == gpfn->framenum) {
gpencil_layer_delframe(gpl, gpf);
BKE_gpencil_layer_delframe(gpl, gpf);
}
}
}
@ -7755,7 +7755,7 @@ static void createTransGPencil(bContext *C, TransInfo *t)
*/
// XXX: should this be allowed when framelock is enabled?
if (gpf->framenum != cfra) {
gpf = gpencil_frame_addcopy(gpl, cfra);
gpf = BKE_gpencil_frame_addcopy(gpl, cfra);
/* in some weird situations (framelock enabled) return NULL */
if (gpf == NULL) {
continue;

50
source/blender/makesrna/intern/rna_gpencil.c
View File

@ -323,7 +323,7 @@ static void rna_GPencil_active_layer_set(PointerRNA *ptr, PointerRNA value)
static int rna_GPencil_active_layer_index_get(PointerRNA *ptr)
{
bGPdata *gpd = (bGPdata *)ptr->id.data;
bGPDlayer *gpl = gpencil_layer_getactive(gpd);
bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
return BLI_findindex(&gpd->layers, gpl);
}
@ -333,7 +333,7 @@ static void rna_GPencil_active_layer_index_set(PointerRNA *ptr, int value)
bGPdata *gpd = (bGPdata *)ptr->id.data;
bGPDlayer *gpl = BLI_findlink(&gpd->layers, value);
gpencil_layer_setactive(gpd, gpl);
BKE_gpencil_layer_setactive(gpd, gpl);
}
static void rna_GPencil_active_layer_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
@ -366,7 +366,7 @@ static void rna_GPencil_use_onion_skinning_set(PointerRNA *ptr, const int value)
/* set new value */
if (value) {
/* enable on active layer (it's the one that's most likely to be of interest right now) */
gpl = gpencil_layer_getactive(gpd);
gpl = BKE_gpencil_layer_getactive(gpd);
if (gpl) {
gpl->flag |= GP_LAYER_ONIONSKIN;
}
@ -435,7 +435,7 @@ static void rna_GPencil_stroke_point_select_set(PointerRNA *ptr, const int value
pt->flag &= ~GP_SPOINT_SELECT;
/* Check if the stroke should be selected or not... */
gpencil_stroke_sync_selection(gps);
BKE_gpencil_stroke_sync_selection(gps);
}
}
@ -534,7 +534,7 @@ static bGPDframe *rna_GPencil_frame_new(bGPDlayer *layer, ReportList *reports, i
return NULL;
}
frame = gpencil_frame_addnew(layer, frame_number);
frame = BKE_gpencil_frame_addnew(layer, frame_number);
WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
@ -549,7 +549,7 @@ static void rna_GPencil_frame_remove(bGPDlayer *layer, ReportList *reports, Poin
return;
}
gpencil_layer_delframe(layer, frame);
BKE_gpencil_layer_delframe(layer, frame);
RNA_POINTER_INVALIDATE(frame_ptr);
WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
@ -557,7 +557,7 @@ static void rna_GPencil_frame_remove(bGPDlayer *layer, ReportList *reports, Poin
static bGPDframe *rna_GPencil_frame_copy(bGPDlayer *layer, bGPDframe *src)
{
bGPDframe *frame = gpencil_frame_duplicate(src);
bGPDframe *frame = BKE_gpencil_frame_duplicate(src);
while (BKE_gpencil_layer_find_frame(layer, frame->framenum)) {
frame->framenum++;
@ -572,7 +572,7 @@ static bGPDframe *rna_GPencil_frame_copy(bGPDlayer *layer, bGPDframe *src)
static bGPDlayer *rna_GPencil_layer_new(bGPdata *gpd, const char *name, int setactive)
{
bGPDlayer *gl = gpencil_layer_addnew(gpd, name, setactive != 0);
bGPDlayer *gl = BKE_gpencil_layer_addnew(gpd, name, setactive != 0);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -587,7 +587,7 @@ static void rna_GPencil_layer_remove(bGPdata *gpd, ReportList *reports, PointerR
return;
}
gpencil_layer_delete(gpd, layer);
BKE_gpencil_layer_delete(gpd, layer);
RNA_POINTER_INVALIDATE(layer_ptr);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -595,21 +595,21 @@ static void rna_GPencil_layer_remove(bGPdata *gpd, ReportList *reports, PointerR
static void rna_GPencil_frame_clear(bGPDframe *frame)
{
free_gpencil_strokes(frame);
BKE_gpencil_free_strokes(frame);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
}
static void rna_GPencil_layer_clear(bGPDlayer *layer)
{
free_gpencil_frames(layer);
BKE_gpencil_free_frames(layer);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
}
static void rna_GPencil_clear(bGPdata *gpd)
{
free_gpencil_layers(&gpd->layers);
BKE_gpencil_free_layers(&gpd->layers);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
}
@ -617,7 +617,7 @@ static void rna_GPencil_clear(bGPdata *gpd)
/* Palettes */
static bGPDpalette *rna_GPencil_palette_new(bGPdata *gpd, const char *name, int setactive)
{
bGPDpalette *palette = gpencil_palette_addnew(gpd, name, setactive != 0);
bGPDpalette *palette = BKE_gpencil_palette_addnew(gpd, name, setactive != 0);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -632,7 +632,7 @@ static void rna_GPencil_palette_remove(bGPdata *gpd, ReportList *reports, Pointe
return;
}
gpencil_palette_delete(gpd, palette);
BKE_gpencil_palette_delete(gpd, palette);
RNA_POINTER_INVALIDATE(palette_ptr);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -675,7 +675,7 @@ static void rna_GPencil_active_palette_set(PointerRNA *ptr, PointerRNA value)
}
}
/* force color recalc */
gpencil_palette_change_strokes(gpd);
BKE_gpencil_palette_change_strokes(gpd);
WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
}
@ -684,7 +684,7 @@ static void rna_GPencil_active_palette_set(PointerRNA *ptr, PointerRNA value)
static int rna_GPencilPalette_index_get(PointerRNA *ptr)
{
bGPdata *gpd = (bGPdata *)ptr->id.data;
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
return BLI_findindex(&gpd->palettes, palette);
}
@ -694,7 +694,7 @@ 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);
BKE_gpencil_palette_setactive(gpd, palette);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
}
@ -712,7 +712,7 @@ static void rna_GPencilPalette_index_range(PointerRNA *ptr, int *min, int *max,
/* Palette colors */
static bGPDpalettecolor *rna_GPencilPalette_color_new(bGPDpalette *palette)
{
bGPDpalettecolor *color = gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
bGPDpalettecolor *color = BKE_gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
return color;
}
@ -726,7 +726,7 @@ static void rna_GPencilPalette_color_remove(bGPDpalette *palette, ReportList *re
return;
}
gpencil_palettecolor_delete(palette, color);
BKE_gpencil_palettecolor_delete(palette, color);
RNA_POINTER_INVALIDATE(color_ptr);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -755,7 +755,7 @@ static void rna_GPencilPalette_active_color_set(PointerRNA *ptr, PointerRNA valu
bGPDpalette *palette = (bGPDpalette *)ptr->data;
bGPDpalettecolor *color = value.data;
gpencil_palettecolor_setactive(palette, color);
BKE_gpencil_palettecolor_setactive(palette, color);
}
static void rna_GPencilPalette_info_set(PointerRNA *ptr, const char *value)
@ -773,7 +773,7 @@ static void rna_GPencilPalette_info_set(PointerRNA *ptr, const char *value)
static char *rna_GPencilPalette_color_path(PointerRNA *ptr)
{
bGPdata *gpd = ptr->id.data;
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = ptr->data;
char name_palette[sizeof(palette->info) * 2];
@ -788,11 +788,11 @@ static char *rna_GPencilPalette_color_path(PointerRNA *ptr)
static void rna_GPencilPaletteColor_info_set(PointerRNA *ptr, const char *value)
{
bGPdata *gpd = ptr->id.data;
bGPDpalette *palette = gpencil_palette_getactive(gpd);
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = ptr->data;
/* rename all strokes */
gpencil_palettecolor_changename(gpd, palcolor->info, value);
BKE_gpencil_palettecolor_changename(gpd, palcolor->info, value);
/* copy the new name into the name slot */
BLI_strncpy_utf8(palcolor->info, value, sizeof(palcolor->info));
@ -824,7 +824,7 @@ static int rna_GPencilPaletteColor_is_fill_visible_get(PointerRNA *ptr)
static int rna_GPencilPaletteColor_index_get(PointerRNA *ptr)
{
bGPDpalette *palette = (bGPDpalette *)ptr->data;
bGPDpalettecolor *pcolor = gpencil_palettecolor_getactive(palette);
bGPDpalettecolor *pcolor = BKE_gpencil_palettecolor_getactive(palette);
return BLI_findindex(&palette->colors, pcolor);
}
@ -833,7 +833,7 @@ 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);
BKE_gpencil_palettecolor_setactive(palette, pcolor);
}
static void rna_GPencilPaletteColor_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)

2
source/blender/makesrna/intern/rna_main_api.c
View File

@ -1564,7 +1564,7 @@ void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
parm = RNA_def_boolean(func, "value", 0, "Value", "");
RNA_def_property_flag(parm, PROP_REQUIRED);
func = RNA_def_function(srna, "new", "gpencil_data_addnew");
func = RNA_def_function(srna, "new", "BKE_gpencil_data_addnew");
RNA_def_function_flag(func, FUNC_NO_SELF);
parm = RNA_def_string(func, "name", "GreasePencil", 0, "", "New name for the data-block");
RNA_def_property_flag(parm, PROP_REQUIRED);

8
source/blender/makesrna/intern/rna_scene.c
View File

@ -454,7 +454,7 @@ EnumPropertyItem rna_enum_bake_pass_filter_type_items[] = {
/* Grease pencil Drawing Brushes */
static bGPDbrush *rna_GPencil_brush_new(ToolSettings *ts, const char *name, int setactive)
{
bGPDbrush *brush = gpencil_brush_addnew(ts, name, setactive != 0);
bGPDbrush *brush = BKE_gpencil_brush_addnew(ts, name, setactive != 0);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -469,7 +469,7 @@ static void rna_GPencil_brush_remove(ToolSettings *ts, ReportList *reports, Poin
return;
}
gpencil_brush_delete(ts, brush);
BKE_gpencil_brush_delete(ts, brush);
RNA_POINTER_INVALIDATE(brush_ptr);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
@ -514,7 +514,7 @@ static void rna_GPencil_active_brush_set(PointerRNA *ptr, PointerRNA value)
static int rna_GPencilBrush_index_get(PointerRNA *ptr)
{
ToolSettings *ts = (ToolSettings *) ptr->data;
bGPDbrush *brush = gpencil_brush_getactive(ts);
bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
return BLI_findindex(&ts->gp_brushes, brush);
}
@ -525,7 +525,7 @@ static void rna_GPencilBrush_index_set(PointerRNA *ptr, int value)
bGPDbrush *brush = BLI_findlink(&ts->gp_brushes, value);
gpencil_brush_setactive(ts, brush);
BKE_gpencil_brush_setactive(ts, brush);
WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
}