GPencil: Cleanup - Rename annotation function to new prefix

These functions were using the old gpencil or gp prefix.

1 files changed, 226 insertions, 225 deletions

diff --git a/source/blender/editors/gpencil/annotate_paint.c b/source/blender/editors/gpencil/annotate_paint.c
index 2bd83475f00..9fc3e864f54 100644
--- a/source/blender/editors/gpencil/annotate_paint.c
+++ b/source/blender/editors/gpencil/annotate_paint.c
@@ -204,12 +204,12 @@ typedef struct tGPsdata {
 /* minimum length of new segment before new point can be added */
 #define MIN_EUCLIDEAN_PX (U.gp_euclideandist)
 
-static bool gp_stroke_added_check(tGPsdata *p)
+static bool annotation_stroke_added_check(tGPsdata *p)
 {
   return (p->gpf && p->gpf->strokes.last && p->flags & GP_PAINTFLAG_STROKEADDED);
 }
 
-static void gp_stroke_added_enable(tGPsdata *p)
+static void annotation_stroke_added_enable(tGPsdata *p)
 {
   BLI_assert(p->gpf->strokes.last != NULL);
   p->flags |= GP_PAINTFLAG_STROKEADDED;
@@ -218,13 +218,13 @@ static void gp_stroke_added_enable(tGPsdata *p)
 /* ------ */
 /* Forward defines for some functions... */
 
-static void gp_session_validatebuffer(tGPsdata *p);
+static void annotation_session_validatebuffer(tGPsdata *p);
 
 /* ******************************************* */
 /* Context Wrangling... */
 
 /* check if context is suitable for drawing */
-static bool gpencil_draw_poll(bContext *C)
+static bool annotation_draw_poll(bContext *C)
 {
   if (ED_operator_regionactive(C)) {
     /* check if current context can support GPencil data */
@@ -249,7 +249,7 @@ static bool gpencil_draw_poll(bContext *C)
 }
 
 /* check if projecting strokes into 3d-geometry in the 3D-View */
-static bool gpencil_project_check(tGPsdata *p)
+static bool annotation_project_check(tGPsdata *p)
 {
   bGPdata *gpd = p->gpd;
   return ((gpd->runtime.sbuffer_sflag & GP_STROKE_3DSPACE) &&
@@ -262,7 +262,7 @@ static bool gpencil_project_check(tGPsdata *p)
 /* Utilities --------------------------------- */
 
 /* get the reference point for stroke-point conversions */
-static void gp_get_3d_reference(tGPsdata *p, float vec[3])
+static void annotation_get_3d_reference(tGPsdata *p, float vec[3])
 {
   const float *fp = p->scene->cursor.location;
 
@@ -273,7 +273,7 @@ static void gp_get_3d_reference(tGPsdata *p, float vec[3])
 /* Stroke Editing ---------------------------- */
 
 /* check if the current mouse position is suitable for adding a new point */
-static bool gp_stroke_filtermval(tGPsdata *p, const float mval[2], float pmval[2])
+static bool annotation_stroke_filtermval(tGPsdata *p, const float mval[2], float pmval[2])
 {
   int dx = (int)fabsf(mval[0] - pmval[0]);
   int dy = (int)fabsf(mval[1] - pmval[1]);
@@ -318,7 +318,10 @@ static bool gp_stroke_filtermval(tGPsdata *p, const float mval[2], float pmval[2
 }
 
 /* convert screen-coordinates to buffer-coordinates */
-static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[3], float *depth)
+static void annotation_stroke_convertcoords(tGPsdata *p,
+                                            const float mval[2],
+                                            float out[3],
+                                            float *depth)
 {
   bGPdata *gpd = p->gpd;
 
@@ -326,7 +329,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[
   if (gpd->runtime.sbuffer_sflag & GP_STROKE_3DSPACE) {
     int mval_i[2];
     round_v2i_v2fl(mval_i, mval);
-    if (gpencil_project_check(p) &&
+    if (annotation_project_check(p) &&
         (ED_view3d_autodist_simple(p->region, mval_i, out, 0, depth))) {
       /* projecting onto 3D-Geometry
        * - nothing more needs to be done here, since view_autodist_simple() has already done it
@@ -346,7 +349,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[
        *   reference point instead or as offset, for easier stroke matching
        */
 
-      gp_get_3d_reference(p, rvec);
+      annotation_get_3d_reference(p, rvec);
       zfac = ED_view3d_calc_zfac(p->region->regiondata, rvec, NULL);
 
       if (ED_view3d_project_float_global(p->region, rvec, mval_prj, V3D_PROJ_TEST_NOP) ==
@@ -391,7 +394,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[
  * \param inf: Influence factor
  * \param idx: Index of the last point (need minimum 3 points in the array)
  */
-static void gp_smooth_buffer(tGPsdata *p, float inf, int idx)
+static void annotation_smooth_buffer(tGPsdata *p, float inf, int idx)
 {
   bGPdata *gpd = p->gpd;
   short num_points = gpd->runtime.sbuffer_used;
@@ -439,12 +442,12 @@ static void gp_smooth_buffer(tGPsdata *p, float inf, int idx)
   copy_v2_v2(&ptc->x, c);
 }
 
-static void gp_stroke_arrow_calc_points_segment(float stroke_points[8],
-                                                const float ref_point[2],
-                                                const float dir_cw[2],
-                                                const float dir_ccw[2],
-                                                const float lenght,
-                                                const float sign)
+static void annotation_stroke_arrow_calc_points_segment(float stroke_points[8],
+                                                        const float ref_point[2],
+                                                        const float dir_cw[2],
+                                                        const float dir_ccw[2],
+                                                        const float lenght,
+                                                        const float sign)
 {
   stroke_points[0] = ref_point[0] + dir_cw[0] * lenght * sign;
   stroke_points[1] = ref_point[1] + dir_cw[1] * lenght * sign;
@@ -452,7 +455,7 @@ static void gp_stroke_arrow_calc_points_segment(float stroke_points[8],
   stroke_points[3] = ref_point[1] + dir_ccw[1] * lenght * sign;
 }
 
-static void gp_stroke_arrow_calc_points(tGPspoint *point,
+static void annotation_stroke_arrow_calc_points(tGPspoint *point,
                                         const float stroke_dir[2],
                                         float corner[2],
                                         float stroke_points[8],
@@ -474,12 +477,12 @@ static void gp_stroke_arrow_calc_points(tGPspoint *point,
       stroke_points[3] = corner[1] + inv_norm_dir_counterclockwise[1] * arrow_lenght + norm_dir[1];
       break;
     case GP_STROKE_ARROWSTYLE_SEGMENT:
-      gp_stroke_arrow_calc_points_segment(stroke_points,
-                                          corner,
-                                          inv_norm_dir_clockwise,
-                                          inv_norm_dir_counterclockwise,
-                                          arrow_lenght,
-                                          1.0f);
+      annotation_stroke_arrow_calc_points_segment(stroke_points,
+                                                  corner,
+                                                  inv_norm_dir_clockwise,
+                                                  inv_norm_dir_counterclockwise,
+                                                  arrow_lenght,
+                                                  1.0f);
       break;
     case GP_STROKE_ARROWSTYLE_CLOSED:
       mul_v2_fl(norm_dir, arrow_lenght);
@@ -487,12 +490,12 @@ static void gp_stroke_arrow_calc_points(tGPspoint *point,
         add_v2_v2(&point->x, norm_dir);
         copy_v2_v2(corner, &point->x);
       }
-      gp_stroke_arrow_calc_points_segment(stroke_points,
-                                          corner,
-                                          inv_norm_dir_clockwise,
-                                          inv_norm_dir_counterclockwise,
-                                          arrow_lenght,
-                                          -1.0f);
+      annotation_stroke_arrow_calc_points_segment(stroke_points,
+                                                  corner,
+                                                  inv_norm_dir_clockwise,
+                                                  inv_norm_dir_counterclockwise,
+                                                  arrow_lenght,
+                                                  -1.0f);
       stroke_points[4] = corner[0] - norm_dir[0];
       stroke_points[5] = corner[1] - norm_dir[1];
       break;
@@ -502,12 +505,12 @@ static void gp_stroke_arrow_calc_points(tGPspoint *point,
         add_v2_v2(&point->x, norm_dir);
         copy_v2_v2(corner, &point->x);
       }
-      gp_stroke_arrow_calc_points_segment(stroke_points,
-                                          corner,
-                                          inv_norm_dir_clockwise,
-                                          inv_norm_dir_counterclockwise,
-                                          arrow_lenght * 0.75f,
-                                          -1.0f);
+      annotation_stroke_arrow_calc_points_segment(stroke_points,
+                                                  corner,
+                                                  inv_norm_dir_clockwise,
+                                                  inv_norm_dir_counterclockwise,
+                                                  arrow_lenght * 0.75f,
+                                                  -1.0f);
       stroke_points[4] = stroke_points[0] - norm_dir[0];
       stroke_points[5] = stroke_points[1] - norm_dir[1];
       stroke_points[6] = stroke_points[2] - norm_dir[0];
@@ -519,7 +522,10 @@ static void gp_stroke_arrow_calc_points(tGPspoint *point,
 }
 
 /* add current stroke-point to buffer (returns whether point was successfully added) */
-static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure, double curtime)
+static short annotation_stroke_addpoint(tGPsdata *p,
+                                        const float mval[2],
+                                        float pressure,
+                                        double curtime)
 {
   bGPdata *gpd = p->gpd;
   tGPspoint *pt;
@@ -572,14 +578,14 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure
           pt++;
           float e_heading[2] = {start[0] - end[0], start[1] - end[1]};
           /* Calculate points for ending arrow. */
-          gp_stroke_arrow_calc_points(
+          annotation_stroke_arrow_calc_points(
               pt, e_heading, end, gpd->runtime.arrow_end, gpd->runtime.arrow_end_style);
         }
         /* Arrow start corner. */
         if (gpd->runtime.sbuffer_sflag & GP_STROKE_USE_ARROW_START) {
           float s_heading[2] = {end[0] - start[0], end[1] - start[1]};
           /* Calculate points for starting arrow. */
-          gp_stroke_arrow_calc_points(
+          annotation_stroke_arrow_calc_points(
               NULL, s_heading, start, gpd->runtime.arrow_start, gpd->runtime.arrow_start_style);
         }
       }
@@ -612,7 +618,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure
     if ((p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) == 0) {
       /* smooth while drawing previous points with a reduction factor for previous */
       for (int s = 0; s < 3; s++) {
-        gp_smooth_buffer(p, 0.5f * ((3.0f - s) / 3.0f), gpd->runtime.sbuffer_used - s);
+        annotation_smooth_buffer(p, 0.5f * ((3.0f - s) / 3.0f), gpd->runtime.sbuffer_used - s);
       }
     }
 
@@ -633,7 +639,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure
      * to stroke. This allows to draw lines more interactively (see new segment
      * during mouse slide, e.g.)
      */
-    if (gp_stroke_added_check(p)) {
+    if (annotation_stroke_added_check(p)) {
       bGPDstroke *gps = p->gpf->strokes.last;
       bGPDspoint *pts;
 
@@ -650,7 +656,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure
        * but poly lines are converting to stroke instantly,
        * so initialize depth buffer before converting coordinates
        */
-      if (gpencil_project_check(p)) {
+      if (annotation_project_check(p)) {
         View3D *v3d = p->area->spacedata.first;
 
         view3d_region_operator_needs_opengl(p->win, p->region);
@@ -661,7 +667,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure
       }
 
       /* convert screen-coordinates to appropriate coordinates (and store them) */
-      gp_stroke_convertcoords(p, &pt->x, &pts->x, NULL);
+      annotation_stroke_convertcoords(p, &pt->x, &pts->x, NULL);
 
       /* copy pressure and time */
       pts->pressure = pt->pressure;
@@ -682,115 +688,115 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure
   return GP_STROKEADD_INVALID;
 }
 
-static void gp_stroke_arrow_init_point_default(bGPDspoint *pt)
+static void annotation_stroke_arrow_init_point_default(bGPDspoint *pt)
 {
   pt->pressure = 1.0f;
   pt->strength = 1.0f;
   pt->time = 1.0f;
 }
 
-static void gp_stroke_arrow_init_conv_point(bGPDspoint *pt, const float point[3])
+static void annotation_stroke_arrow_init_conv_point(bGPDspoint *pt, const float point[3])
 {
   copy_v3_v3(&pt->x, point);
-  gp_stroke_arrow_init_point_default(pt);
+  annotation_stroke_arrow_init_point_default(pt);
 }
 
-static void gp_stroke_arrow_init_point(
+static void annotation_stroke_arrow_init_point(
     tGPsdata *p, tGPspoint *ptc, bGPDspoint *pt, const float co[8], const int co_idx)
 {
   /* Note: provided co_idx should be always pair number as it's [x1, y1, x2, y2, x3, y3]. */
   float real_co[2] = {co[co_idx], co[co_idx + 1]};
   copy_v2_v2(&ptc->x, real_co);
-  gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
-  gp_stroke_arrow_init_point_default(pt);
+  annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
+  annotation_stroke_arrow_init_point_default(pt);
 }
 
-static void gp_stroke_arrow_allocate(bGPDstroke *gps, const int totpoints)
+static void annotation_stroke_arrow_allocate(bGPDstroke *gps, const int totpoints)
 {
   /* Copy appropriate settings for stroke. */
   gps->totpoints = totpoints;
   /* Allocate enough memory for a continuous array for storage points. */
-  gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
+  gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "annotation_stroke_points");
 }
 
-static void gp_arrow_create_open(tGPsdata *p,
-                                 tGPspoint *ptc,
-                                 bGPDspoint *pt,
-                                 const float corner_point[3],
-                                 const float arrow_points[8])
+static void annotation_arrow_create_open(tGPsdata *p,
+                                         tGPspoint *ptc,
+                                         bGPDspoint *pt,
+                                         const float corner_point[3],
+                                         const float arrow_points[8])
 {
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
   pt++;
-  gp_stroke_arrow_init_conv_point(pt, corner_point);
+  annotation_stroke_arrow_init_conv_point(pt, corner_point);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2);
 }
 
-static void gp_arrow_create_segm(tGPsdata *p,
-                                 tGPspoint *ptc,
-                                 bGPDspoint *pt,
-                                 const float arrow_points[8])
+static void annotation_arrow_create_segm(tGPsdata *p,
+                                         tGPspoint *ptc,
+                                         bGPDspoint *pt,
+                                         const float arrow_points[8])
 {
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2);
 }
 
-static void gp_arrow_create_closed(tGPsdata *p,
-                                   tGPspoint *ptc,
-                                   bGPDspoint *pt,
-                                   const float arrow_points[8])
+static void annotation_arrow_create_closed(tGPsdata *p,
+                                           tGPspoint *ptc,
+                                           bGPDspoint *pt,
+                                           const float arrow_points[8])
 {
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 4);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 4);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
 }
 
-static void gp_arrow_create_square(tGPsdata *p,
-                                   tGPspoint *ptc,
-                                   bGPDspoint *pt,
-                                   const float corner_point[3],
-                                   const float arrow_points[8])
+static void annotation_arrow_create_square(tGPsdata *p,
+                                           tGPspoint *ptc,
+                                           bGPDspoint *pt,
+                                           const float corner_point[3],
+                                           const float arrow_points[8])
 {
-  gp_stroke_arrow_init_conv_point(pt, corner_point);
+  annotation_stroke_arrow_init_conv_point(pt, corner_point);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 4);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 4);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 6);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 6);
   pt++;
-  gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2);
+  annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2);
   pt++;
-  gp_stroke_arrow_init_conv_point(pt, corner_point);
+  annotation_stroke_arrow_init_conv_point(pt, corner_point);
 }
 
-static void gp_arrow_create(tGPsdata *p,
-                            tGPspoint *ptc,
-                            bGPDspoint *pt,
-                            bGPDstroke *arrow_stroke,
-                            const float arrow_points[8],
-                            const int style)
+static void annotation_arrow_create(tGPsdata *p,
+                                    tGPspoint *ptc,
+                                    bGPDspoint *pt,
+                                    bGPDstroke *arrow_stroke,
+                                    const float arrow_points[8],
+                                    const int style)
 {
   float corner_conv[3];
   copy_v3_v3(corner_conv, &pt->x);
 
   switch (style) {
     case GP_STROKE_ARROWSTYLE_SEGMENT:
-      gp_arrow_create_segm(p, ptc, pt, arrow_points);
+      annotation_arrow_create_segm(p, ptc, pt, arrow_points);
       break;
     case GP_STROKE_ARROWSTYLE_CLOSED:
-      gp_arrow_create_closed(p, ptc, pt, arrow_points);
+      annotation_arrow_create_closed(p, ptc, pt, arrow_points);
       break;
     case GP_STROKE_ARROWSTYLE_OPEN:
-      gp_arrow_create_open(p, ptc, pt, corner_conv, arrow_points);
+      annotation_arrow_create_open(p, ptc, pt, corner_conv, arrow_points);
       break;
     case GP_STROKE_ARROWSTYLE_SQUARE:
-      gp_arrow_create_square(p, ptc, pt, corner_conv, arrow_points);
+      annotation_arrow_create_square(p, ptc, pt, corner_conv, arrow_points);
       break;
     default:
       break;
@@ -800,7 +806,7 @@ static void gp_arrow_create(tGPsdata *p,
 }
 
 /* make a new stroke from the buffer data */
-static void gp_stroke_newfrombuffer(tGPsdata *p)
+static void annotation_stroke_newfrombuffer(tGPsdata *p)
 {
   bGPdata *gpd = p->gpd;
   bGPDlayer *gpl = p->gpl;
@@ -838,13 +844,13 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
    * interactive behavior
    */
   if (p->paintmode == GP_PAINTMODE_DRAW_POLY) {
-    if (gp_stroke_added_check(p)) {
+    if (annotation_stroke_added_check(p)) {
       return;
     }
   }
 
   /* allocate memory for a new stroke */
-  gps = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
+  gps = MEM_callocN(sizeof(bGPDstroke), "annotation_stroke");
 
   /* copy appropriate settings for stroke */
   gps->totpoints = totelem;
@@ -858,7 +864,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
   gps->tot_triangles = 0;
 
   /* allocate enough memory for a continuous array for storage points */
-  gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
+  gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "annotation_stroke_points");
   gps->tot_triangles = 0;
 
   /* set pointer to first non-initialized point */
@@ -872,7 +878,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
       ptc = gpd->runtime.sbuffer;
 
       /* convert screen-coordinates to appropriate coordinates (and store them) */
-      gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
+      annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
 
       /* copy pressure and time */
       pt->pressure = ptc->pressure;
@@ -890,7 +896,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
       ptc = ((tGPspoint *)runtime.sbuffer) + (runtime.sbuffer_used - 1);
 
       /* Convert screen-coordinates to appropriate coordinates (and store them). */
-      gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
+      annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
 
       /* Copy pressure and time. */
       pt->pressure = ptc->pressure;
@@ -906,18 +912,19 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 
         /* Setting up arrow stroke. */
         bGPDstroke *e_arrow_gps = BKE_gpencil_stroke_duplicate(gps, false);
-        gp_stroke_arrow_allocate(e_arrow_gps, totarrowpoints);
+        annotation_stroke_arrow_allocate(e_arrow_gps, totarrowpoints);
 
         /* Set pointer to first non-initialized point. */
         pt = e_arrow_gps->points + (e_arrow_gps->totpoints - totarrowpoints);
 
         /* End point. */
         ptc = ((tGPspoint *)runtime.sbuffer) + (runtime.sbuffer_used - 1);
-        gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
-        gp_stroke_arrow_init_point_default(pt);
+        annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
+        annotation_stroke_arrow_init_point_default(pt);
 
         /* Fill and convert arrow points to create arrow shape. */
-        gp_arrow_create(p, ptc, pt, e_arrow_gps, runtime.arrow_end, runtime.arrow_end_style);
+        annotation_arrow_create(
+            p, ptc, pt, e_arrow_gps, runtime.arrow_end, runtime.arrow_end_style);
       }
       /* Start arrow stroke. */
       if ((runtime.sbuffer_sflag & GP_STROKE_USE_ARROW_START) &&
@@ -926,18 +933,19 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 
         /* Setting up arrow stroke. */
         bGPDstroke *s_arrow_gps = BKE_gpencil_stroke_duplicate(gps, false);
-        gp_stroke_arrow_allocate(s_arrow_gps, totarrowpoints);
+        annotation_stroke_arrow_allocate(s_arrow_gps, totarrowpoints);
 
         /* Set pointer to first non-initialized point. */
         pt = s_arrow_gps->points + (s_arrow_gps->totpoints - totarrowpoints);
 
         /* Start point. */
         ptc = runtime.sbuffer;
-        gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
-        gp_stroke_arrow_init_point_default(pt);
+        annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
+        annotation_stroke_arrow_init_point_default(pt);
 
         /* Fill and convert arrow points to create arrow shape. */
-        gp_arrow_create(p, ptc, pt, s_arrow_gps, runtime.arrow_start, runtime.arrow_start_style);
+        annotation_arrow_create(
+            p, ptc, pt, s_arrow_gps, runtime.arrow_start, runtime.arrow_start_style);
       }
     }
   }
@@ -946,7 +954,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
     ptc = gpd->runtime.sbuffer;
 
     /* convert screen-coordinates to appropriate coordinates (and store them) */
-    gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
+    annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
 
     /* copy pressure and time */
     pt->pressure = ptc->pressure;
@@ -957,7 +965,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
     float *depth_arr = NULL;
 
     /* get an array of depths, far depths are blended */
-    if (gpencil_project_check(p)) {
+    if (annotation_project_check(p)) {
       int mval_i[2], mval_prev[2] = {0};
       int interp_depth = 0;
       int found_depth = 0;
@@ -1025,7 +1033,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
     for (i = 0, ptc = gpd->runtime.sbuffer; i < gpd->runtime.sbuffer_used && ptc;
          i++, ptc++, pt++) {
       /* convert screen-coordinates to appropriate coordinates (and store them) */
-      gp_stroke_convertcoords(p, &ptc->x, &pt->x, depth_arr ? depth_arr + i : NULL);
+      annotation_stroke_convertcoords(p, &ptc->x, &pt->x, depth_arr ? depth_arr + i : NULL);
 
       /* copy pressure and time */
       pt->pressure = ptc->pressure;
@@ -1041,7 +1049,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 
   /* add stroke to frame */
   BLI_addtail(&p->gpf->strokes, gps);
-  gp_stroke_added_enable(p);
+  annotation_stroke_added_enable(p);
 }
 
 /* --- 'Eraser' for 'Paint' Tool ------ */
@@ -1049,7 +1057,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 /* helper to free a stroke
  * NOTE: gps->dvert and gps->triangles should be NULL, but check anyway for good measure
  */
-static void gp_free_stroke(bGPDframe *gpf, bGPDstroke *gps)
+static void annotation_free_stroke(bGPDframe *gpf, bGPDstroke *gps)
 {
   if (gps->points) {
     MEM_freeN(gps->points);
@@ -1079,10 +1087,10 @@ static float view3d_point_depth(const RegionView3D *rv3d, const float co[3])
 }
 
 /* only erase stroke points that are visible (3d view) */
-static bool gp_stroke_eraser_is_occluded(tGPsdata *p,
-                                         const bGPDspoint *pt,
-                                         const int x,
-                                         const int y)
+static bool annotation_stroke_eraser_is_occluded(tGPsdata *p,
+                                                 const bGPDspoint *pt,
+                                                 const int x,
+                                                 const int y)
 {
   if ((p->area->spacetype == SPACE_VIEW3D) && (p->flags & GP_PAINTFLAG_V3D_ERASER_DEPTH)) {
     RegionView3D *rv3d = p->region->regiondata;
@@ -1101,14 +1109,13 @@ static bool gp_stroke_eraser_is_occluded(tGPsdata *p,
   return false;
 }
 
-/* eraser tool - evaluation per stroke */
-/* TODO: this could really do with some optimization (KD-Tree/BVH?) */
-static void gp_stroke_eraser_dostroke(tGPsdata *p,
-                                      bGPDframe *gpf,
-                                      bGPDstroke *gps,
-                                      const float mval[2],
-                                      const int radius,
-                                      const rcti *rect)
+/* Eraser tool - evaluation per stroke. */
+static void annotation_stroke_eraser_dostroke(tGPsdata *p,
+                                              bGPDframe *gpf,
+                                              bGPDstroke *gps,
+                                              const float mval[2],
+                                              const int radius,
+                                              const rcti *rect)
 {
   bGPDspoint *pt1, *pt2;
   int pc1[2] = {0};
@@ -1119,7 +1126,7 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p,
 
   if (gps->totpoints == 0) {
     /* just free stroke */
-    gp_free_stroke(gpf, gps);
+    annotation_free_stroke(gpf, gps);
   }
   else if (gps->totpoints == 1) {
     /* only process if it hasn't been masked out... */
@@ -1131,7 +1138,7 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p,
         /* only check if point is inside */
         if (len_v2v2_int(mval_i, pc1) <= radius) {
           /* free stroke */
-          gp_free_stroke(gpf, gps);
+          annotation_free_stroke(gpf, gps);
         }
       }
     }
@@ -1176,8 +1183,8 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p,
          *  - this assumes that linewidth is irrelevant
          */
         if (gp_stroke_inside_circle(mval, radius, pc1[0], pc1[1], pc2[0], pc2[1])) {
-          if ((gp_stroke_eraser_is_occluded(p, pt1, pc1[0], pc1[1]) == false) ||
-              (gp_stroke_eraser_is_occluded(p, pt2, pc2[0], pc2[1]) == false)) {
+          if ((annotation_stroke_eraser_is_occluded(p, pt1, pc1[0], pc1[1]) == false) ||
+              (annotation_stroke_eraser_is_occluded(p, pt2, pc2[0], pc2[1]) == false)) {
             /* Edge is affected - Check individual points now */
             if (len_v2v2_int(mval_i, pc1) <= radius) {
               pt1->flag |= GP_SPOINT_TAG;
@@ -1199,7 +1206,7 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p,
 }
 
 /* erase strokes which fall under the eraser strokes */
-static void gp_stroke_doeraser(tGPsdata *p)
+static void annotation_stroke_doeraser(tGPsdata *p)
 {
   bGPDframe *gpf = p->gpf;
   bGPDstroke *gps, *gpn;
@@ -1228,7 +1235,7 @@ static void gp_stroke_doeraser(tGPsdata *p)
      * (e.g. 2D space strokes in the 3D view, if the same datablock is shared)
      */
     if (ED_gpencil_stroke_can_use_direct(p->area, gps)) {
-      gp_stroke_eraser_dostroke(p, gpf, gps, p->mval, p->radius, &rect);
+      annotation_stroke_eraser_dostroke(p, gpf, gps, p->mval, p->radius, &rect);
     }
   }
 }
@@ -1237,7 +1244,7 @@ static void gp_stroke_doeraser(tGPsdata *p)
 /* Sketching Operator */
 
 /* clear the session buffers (call this before AND after a paint operation) */
-static void gp_session_validatebuffer(tGPsdata *p)
+static void annotation_session_validatebuffer(tGPsdata *p)
 {
   bGPdata *gpd = p->gpd;
 
@@ -1252,7 +1259,7 @@ static void gp_session_validatebuffer(tGPsdata *p)
 }
 
 /* (re)init new painting data */
-static bool gp_session_initdata(bContext *C, tGPsdata *p)
+static bool annotation_session_initdata(bContext *C, tGPsdata *p)
 {
   Main *bmain = CTX_data_main(C);
   bGPdata **gpd_ptr = NULL;
@@ -1423,13 +1430,13 @@ static bool gp_session_initdata(bContext *C, tGPsdata *p)
   }
 
   /* clear out buffer (stored in gp-data), in case something contaminated it */
-  gp_session_validatebuffer(p);
+  annotation_session_validatebuffer(p);
 
   return 1;
 }
 
 /* init new painting session */
-static tGPsdata *gp_session_initpaint(bContext *C)
+static tGPsdata *annotation_session_initpaint(bContext *C)
 {
   tGPsdata *p = NULL;
 
@@ -1439,7 +1446,7 @@ static tGPsdata *gp_session_initpaint(bContext *C)
   /* Try to initialize context data
    * WARNING: This may not always succeed (e.g. using GP in an annotation-only context)
    */
-  if (gp_session_initdata(C, p) == 0) {
+  if (annotation_session_initdata(C, p) == 0) {
     /* Invalid state - Exit
      * NOTE: It should be safe to just free the data, since failing context checks should
      * only happen when no data has been allocated.
@@ -1459,7 +1466,7 @@ static tGPsdata *gp_session_initpaint(bContext *C)
 }
 
 /* cleanup after a painting session */
-static void gp_session_cleanup(tGPsdata *p)
+static void annotation_session_cleanup(tGPsdata *p)
 {
   bGPdata *gpd = (p) ? p->gpd : NULL;
 
@@ -1482,13 +1489,15 @@ static void gp_session_cleanup(tGPsdata *p)
   p->inittime = 0.0;
 }
 
-static void gp_session_free(tGPsdata *p)
+static void annotation_session_free(tGPsdata *p)
 {
   MEM_freeN(p);
 }
 
 /* init new stroke */
-static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode, Depsgraph *depsgraph)
+static void annotation_paint_initstroke(tGPsdata *p,
+                                        eGPencil_PaintModes paintmode,
+                                        Depsgraph *depsgraph)
 {
   Scene *scene = p->scene;
   ToolSettings *ts = scene->toolsettings;
@@ -1639,13 +1648,13 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode, Deps
 }
 
 /* finish off a stroke (clears buffer, but doesn't finish the paint operation) */
-static void gp_paint_strokeend(tGPsdata *p)
+static void annotation_paint_strokeend(tGPsdata *p)
 {
   ToolSettings *ts = p->scene->toolsettings;
   /* for surface sketching, need to set the right OpenGL context stuff so that
    * the conversions will project the values correctly...
    */
-  if (gpencil_project_check(p)) {
+  if (annotation_project_check(p)) {
     View3D *v3d = p->area->spacedata.first;
 
     /* need to restore the original projection settings before packing up */
@@ -1657,22 +1666,22 @@ static void gp_paint_strokeend(tGPsdata *p)
   /* check if doing eraser or not */
   if ((p->gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0) {
     /* transfer stroke to frame */
-    gp_stroke_newfrombuffer(p);
+    annotation_stroke_newfrombuffer(p);
   }
 
   /* clean up buffer now */
-  gp_session_validatebuffer(p);
+  annotation_session_validatebuffer(p);
 }
 
 /* finish off stroke painting operation */
-static void gp_paint_cleanup(tGPsdata *p)
+static void annotation_paint_cleanup(tGPsdata *p)
 {
   /* p->gpd==NULL happens when stroke failed to initialize,
    * for example when GP is hidden in current space (sergey)
    */
   if (p->gpd) {
     /* finish off a stroke */
-    gp_paint_strokeend(p);
+    annotation_paint_strokeend(p);
   }
 
   /* "unlock" frame */
@@ -1684,7 +1693,7 @@ static void gp_paint_cleanup(tGPsdata *p)
 /* ------------------------------- */
 
 /* Helper callback for drawing the cursor itself */
-static void gpencil_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr)
+static void annotation_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr)
 {
   tGPsdata *p = (tGPsdata *)p_ptr;
 
@@ -1730,7 +1739,7 @@ static void gpencil_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr)
 }
 
 /* Turn brush cursor in 3D view on/off */
-static void gpencil_draw_toggle_eraser_cursor(tGPsdata *p, short enable)
+static void annotation_draw_toggle_eraser_cursor(tGPsdata *p, short enable)
 {
   if (p->erasercursor && !enable) {
     /* clear cursor */
@@ -1742,11 +1751,11 @@ static void gpencil_draw_toggle_eraser_cursor(tGPsdata *p, short enable)
     p->erasercursor = WM_paint_cursor_activate(SPACE_TYPE_ANY,
                                                RGN_TYPE_ANY,
                                                NULL, /* XXX */
-                                               gpencil_draw_eraser,
+                                               annotation_draw_eraser,
                                                p);
   }
 }
-static void gpencil_draw_stabilizer(bContext *C, int x, int y, void *p_ptr)
+static void annotation_draw_stabilizer(bContext *C, int x, int y, void *p_ptr)
 {
   ARegion *region = CTX_wm_region(C);
   tGPsdata *p = (tGPsdata *)p_ptr;
@@ -1794,7 +1803,7 @@ static void gpencil_draw_stabilizer(bContext *C, int x, int y, void *p_ptr)
 }
 
 /* Turn *stabilizer* brush cursor in 3D view on/off */
-static void gpencil_draw_toggle_stabilizer_cursor(tGPsdata *p, short enable)
+static void annotation_draw_toggle_stabilizer_cursor(tGPsdata *p, short enable)
 {
   if (p->stabilizer_cursor && !enable) {
     /* clear cursor */
@@ -1804,19 +1813,19 @@ static void gpencil_draw_toggle_stabilizer_cursor(tGPsdata *p, short enable)
   else if (enable && !p->stabilizer_cursor) {
     /* enable cursor */
     p->stabilizer_cursor = WM_paint_cursor_activate(
-        SPACE_TYPE_ANY, RGN_TYPE_ANY, NULL, gpencil_draw_stabilizer, p);
+        SPACE_TYPE_ANY, RGN_TYPE_ANY, NULL, annotation_draw_stabilizer, p);
   }
 }
 
 /* Check if tablet eraser is being used (when processing events) */
-static bool gpencil_is_tablet_eraser_active(const wmEvent *event)
+static bool annotation_is_tablet_eraser_active(const wmEvent *event)
 {
   return (event->tablet.active == EVT_TABLET_ERASER);
 }
 
 /* ------------------------------- */
 
-static void gpencil_draw_exit(bContext *C, wmOperator *op)
+static void annotation_draw_exit(bContext *C, wmOperator *op)
 {
   tGPsdata *p = op->customdata;
 
@@ -1828,10 +1837,10 @@ static void gpencil_draw_exit(bContext *C, wmOperator *op)
     /* check size of buffer before cleanup, to determine if anything happened here */
     if (p->paintmode == GP_PAINTMODE_ERASER) {
       /* turn off radial brush cursor */
-      gpencil_draw_toggle_eraser_cursor(p, false);
+      annotation_draw_toggle_eraser_cursor(p, false);
     }
     else if (p->paintmode == GP_PAINTMODE_DRAW) {
-      gpencil_draw_toggle_stabilizer_cursor(p, false);
+      annotation_draw_toggle_stabilizer_cursor(p, false);
     }
 
     /* always store the new eraser size to be used again next time
@@ -1844,40 +1853,40 @@ static void gpencil_draw_exit(bContext *C, wmOperator *op)
     gpencil_undo_finish();
 
     /* cleanup */
-    gp_paint_cleanup(p);
-    gp_session_cleanup(p);
-    gp_session_free(p);
+    annotation_paint_cleanup(p);
+    annotation_session_cleanup(p);
+    annotation_session_free(p);
     p = NULL;
   }
 
   op->customdata = NULL;
 }
 
-static void gpencil_draw_cancel(bContext *C, wmOperator *op)
+static void annotation_draw_cancel(bContext *C, wmOperator *op)
 {
   /* this is just a wrapper around exit() */
-  gpencil_draw_exit(C, op);
+  annotation_draw_exit(C, op);
 }
 
 /* ------------------------------- */
 
-static int gpencil_draw_init(bContext *C, wmOperator *op, const wmEvent *event)
+static int annotation_draw_init(bContext *C, wmOperator *op, const wmEvent *event)
 {
   tGPsdata *p;
   eGPencil_PaintModes paintmode = RNA_enum_get(op->ptr, "mode");
 
   /* check context */
-  p = op->customdata = gp_session_initpaint(C);
+  p = op->customdata = annotation_session_initpaint(C);
   if ((p == NULL) || (p->status == GP_STATUS_ERROR)) {
     /* something wasn't set correctly in context */
-    gpencil_draw_exit(C, op);
+    annotation_draw_exit(C, op);
     return 0;
   }
 
   /* init painting data */
-  gp_paint_initstroke(p, paintmode, CTX_data_ensure_evaluated_depsgraph(C));
+  annotation_paint_initstroke(p, paintmode, CTX_data_ensure_evaluated_depsgraph(C));
   if (p->status == GP_STATUS_ERROR) {
-    gpencil_draw_exit(C, op);
+    annotation_draw_exit(C, op);
     return 0;
   }
 
@@ -1895,7 +1904,7 @@ static int gpencil_draw_init(bContext *C, wmOperator *op, const wmEvent *event)
 /* ------------------------------- */
 
 /* ensure that the correct cursor icon is set */
-static void gpencil_draw_cursor_set(tGPsdata *p)
+static void annotation_draw_cursor_set(tGPsdata *p)
 {
   if (p->paintmode == GP_PAINTMODE_ERASER) {
     WM_cursor_modal_set(p->win, WM_CURSOR_ERASER);
@@ -1906,7 +1915,7 @@ static void gpencil_draw_cursor_set(tGPsdata *p)
 }
 
 /* update UI indicators of status, including cursor and header prints */
-static void gpencil_draw_status_indicators(bContext *C, tGPsdata *p)
+static void annotation_draw_status_indicators(bContext *C, tGPsdata *p)
 {
   /* header prints */
   switch (p->status) {
@@ -1971,12 +1980,12 @@ static void gpencil_draw_status_indicators(bContext *C, tGPsdata *p)
 /* ------------------------------- */
 
 /* create a new stroke point at the point indicated by the painting context */
-static void gpencil_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgraph)
+static void annotation_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgraph)
 {
   /* handle drawing/erasing -> test for erasing first */
   if (p->paintmode == GP_PAINTMODE_ERASER) {
     /* do 'live' erasing now */
-    gp_stroke_doeraser(p);
+    annotation_stroke_doeraser(p);
 
     /* store used values */
     p->mvalo[0] = p->mval[0];
@@ -1985,7 +1994,7 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgraph
   }
   /* Only add current point to buffer if mouse moved
    * (even though we got an event, it might be just noise). */
-  else if (gp_stroke_filtermval(p, p->mval, p->mvalo)) {
+  else if (annotation_stroke_filtermval(p, p->mval, p->mvalo)) {
     /* If lazy mouse, interpolate the last and current mouse positions. */
     if (p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) {
       float now_mouse[2];
@@ -1997,26 +2006,24 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgraph
     }
 
     /* try to add point */
-    short ok = gp_stroke_addpoint(p, p->mval, p->pressure, p->curtime);
+    short ok = annotation_stroke_addpoint(p, p->mval, p->pressure, p->curtime);
 
     /* handle errors while adding point */
     if ((ok == GP_STROKEADD_FULL) || (ok == GP_STROKEADD_OVERFLOW)) {
       /* finish off old stroke */
-      gp_paint_strokeend(p);
+      annotation_paint_strokeend(p);
       /* And start a new one!!! Else, projection errors! */
-      gp_paint_initstroke(p, p->paintmode, depsgraph);
+      annotation_paint_initstroke(p, p->paintmode, depsgraph);
 
       /* start a new stroke, starting from previous point */
-      /* XXX Must manually reset inittime... */
-      /* XXX We only need to reuse previous point if overflow! */
       if (ok == GP_STROKEADD_OVERFLOW) {
         p->inittime = p->ocurtime;
-        gp_stroke_addpoint(p, p->mvalo, p->opressure, p->ocurtime);
+        annotation_stroke_addpoint(p, p->mvalo, p->opressure, p->ocurtime);
       }
       else {
         p->inittime = p->curtime;
       }
-      gp_stroke_addpoint(p, p->mval, p->pressure, p->curtime);
+      annotation_stroke_addpoint(p, p->mval, p->pressure, p->curtime);
     }
     else if (ok == GP_STROKEADD_INVALID) {
       /* the painting operation cannot continue... */
@@ -2056,14 +2063,14 @@ static void annotation_draw_apply_event(
     /* Using permanent stabilization, shift will deactivate the flag. */
     if (p->flags & GP_PAINTFLAG_USE_STABILIZER) {
       if (p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) {
-        gpencil_draw_toggle_stabilizer_cursor(p, false);
+        annotation_draw_toggle_stabilizer_cursor(p, false);
         p->flags &= ~GP_PAINTFLAG_USE_STABILIZER_TEMP;
       }
     }
     /* Not using any stabilization flag. Activate temporal one. */
     else if ((p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) == 0) {
       p->flags |= GP_PAINTFLAG_USE_STABILIZER_TEMP;
-      gpencil_draw_toggle_stabilizer_cursor(p, true);
+      annotation_draw_toggle_stabilizer_cursor(p, true);
     }
   }
   /* verify key status for straight lines */
@@ -2092,7 +2099,7 @@ static void annotation_draw_apply_event(
        so activate the temp flag back again. */
     if (p->flags & GP_PAINTFLAG_USE_STABILIZER) {
       if ((p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) == 0) {
-        gpencil_draw_toggle_stabilizer_cursor(p, true);
+        annotation_draw_toggle_stabilizer_cursor(p, true);
         p->flags |= GP_PAINTFLAG_USE_STABILIZER_TEMP;
       }
     }
@@ -2102,7 +2109,7 @@ static void annotation_draw_apply_event(
     else if (p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) {
       /* Reset temporal stabilizer flag and remove cursor. */
       p->flags &= ~GP_PAINTFLAG_USE_STABILIZER_TEMP;
-      gpencil_draw_toggle_stabilizer_cursor(p, false);
+      annotation_draw_toggle_stabilizer_cursor(p, false);
     }
   }
 
@@ -2166,7 +2173,7 @@ static void annotation_draw_apply_event(
   RNA_float_set(&itemptr, "time", p->curtime - p->inittime);
 
   /* apply the current latest drawing point */
-  gpencil_draw_apply(op, p, depsgraph);
+  annotation_draw_apply(op, p, depsgraph);
 
   /* force refresh */
   /* just active area for now, since doing whole screen is too slow */
@@ -2176,7 +2183,7 @@ static void annotation_draw_apply_event(
 /* ------------------------------- */
 
 /* operator 'redo' (i.e. after changing some properties, but also for repeat last) */
-static int gpencil_draw_exec(bContext *C, wmOperator *op)
+static int annotation_draw_exec(bContext *C, wmOperator *op)
 {
   tGPsdata *p = NULL;
   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
@@ -2184,7 +2191,7 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op)
   /* printf("GPencil - Starting Re-Drawing\n"); */
 
   /* try to initialize context data needed while drawing */
-  if (!gpencil_draw_init(C, op, NULL)) {
+  if (!annotation_draw_init(C, op, NULL)) {
     if (op->customdata) {
       MEM_freeN(op->customdata);
     }
@@ -2218,8 +2225,8 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op)
        */
       if ((p->flags & GP_PAINTFLAG_FIRSTRUN) == 0) {
         /* TODO: both of these ops can set error-status, but we probably don't need to worry */
-        gp_paint_strokeend(p);
-        gp_paint_initstroke(p, p->paintmode, depsgraph);
+        annotation_paint_strokeend(p);
+        annotation_paint_initstroke(p, p->paintmode, depsgraph);
       }
     }
 
@@ -2234,14 +2241,14 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op)
     }
 
     /* apply this data as necessary now (as per usual) */
-    gpencil_draw_apply(op, p, depsgraph);
+    annotation_draw_apply(op, p, depsgraph);
   }
   RNA_END;
 
   /* printf("\tGP - done\n"); */
 
   /* cleanup */
-  gpencil_draw_exit(C, op);
+  annotation_draw_exit(C, op);
 
   /* refreshes */
   WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
@@ -2253,12 +2260,12 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op)
 /* ------------------------------- */
 
 /* start of interactive drawing part of operator */
-static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event)
+static int annotation_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
   tGPsdata *p = NULL;
 
   /* support for tablets eraser pen */
-  if (gpencil_is_tablet_eraser_active(event)) {
+  if (annotation_is_tablet_eraser_active(event)) {
     RNA_enum_set(op->ptr, "mode", GP_PAINTMODE_ERASER);
   }
 
@@ -2267,7 +2274,7 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event
   }
 
   /* try to initialize context data needed while drawing */
-  if (!gpencil_draw_init(C, op, event)) {
+  if (!annotation_draw_init(C, op, event)) {
     if (op->customdata) {
       MEM_freeN(op->customdata);
     }
@@ -2282,21 +2289,15 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event
 
   /* if empty erase capture and finish */
   if (p->status == GP_STATUS_CAPTURE) {
-    gpencil_draw_exit(C, op);
+    annotation_draw_exit(C, op);
 
     BKE_report(op->reports, RPT_ERROR, "Nothing to erase");
     return OPERATOR_FINISHED;
   }
 
-  /* TODO: set any additional settings that we can take from the events?
-   * TODO? if tablet is erasing, force eraser to be on? */
-
-  /* TODO: move cursor setting stuff to stroke-start so that paintmode can be changed midway...
-   */
-
   /* if eraser is on, draw radial aid */
   if (p->paintmode == GP_PAINTMODE_ERASER) {
-    gpencil_draw_toggle_eraser_cursor(p, true);
+    annotation_draw_toggle_eraser_cursor(p, true);
   }
   else if (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT) {
     if (RNA_enum_get(op->ptr, "arrowstyle_start") != GP_STROKE_ARROWSTYLE_NONE) {
@@ -2313,18 +2314,18 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event
     p->stabilizer_radius = RNA_int_get(op->ptr, "stabilizer_radius");
     if (RNA_boolean_get(op->ptr, "use_stabilizer")) {
       p->flags |= GP_PAINTFLAG_USE_STABILIZER | GP_PAINTFLAG_USE_STABILIZER_TEMP;
-      gpencil_draw_toggle_stabilizer_cursor(p, true);
+      annotation_draw_toggle_stabilizer_cursor(p, true);
     }
     else if (event->shift > 0) {
       p->flags |= GP_PAINTFLAG_USE_STABILIZER_TEMP;
-      gpencil_draw_toggle_stabilizer_cursor(p, true);
+      annotation_draw_toggle_stabilizer_cursor(p, true);
     }
   }
   /* set cursor
    * NOTE: This may change later (i.e. intentionally via brush toggle,
    *       or unintentionally if the user scrolls outside the area)...
    */
-  gpencil_draw_cursor_set(p);
+  annotation_draw_cursor_set(p);
 
   /* only start drawing immediately if we're allowed to do so... */
   if (RNA_boolean_get(op->ptr, "wait_for_input") == false) {
@@ -2349,13 +2350,13 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event
 }
 
 /* gpencil modal operator stores area, which can be removed while using it (like fullscreen) */
-static bool gpencil_area_exists(bContext *C, ScrArea *area_test)
+static bool annotation_area_exists(bContext *C, ScrArea *area_test)
 {
   bScreen *screen = CTX_wm_screen(C);
   return (BLI_findindex(&screen->areabase, area_test) != -1);
 }
 
-static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op)
+static tGPsdata *annotation_stroke_begin(bContext *C, wmOperator *op)
 {
   tGPsdata *p = op->customdata;
 
@@ -2373,8 +2374,8 @@ static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op)
   /* XXX: watch it with the paintmode! in future,
    *      it'd be nice to allow changing paint-mode when in sketching-sessions */
 
-  if (gp_session_initdata(C, p)) {
-    gp_paint_initstroke(p, p->paintmode, CTX_data_ensure_evaluated_depsgraph(C));
+  if (annotation_session_initdata(C, p)) {
+    annotation_paint_initstroke(p, p->paintmode, CTX_data_ensure_evaluated_depsgraph(C));
   }
 
   if (p->status != GP_STATUS_ERROR) {
@@ -2385,15 +2386,15 @@ static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op)
   return op->customdata;
 }
 
-static void gpencil_stroke_end(wmOperator *op)
+static void annotation_stroke_end(wmOperator *op)
 {
   tGPsdata *p = op->customdata;
 
-  gp_paint_cleanup(p);
+  annotation_paint_cleanup(p);
 
   gpencil_undo_push(p->gpd);
 
-  gp_session_cleanup(p);
+  annotation_session_cleanup(p);
 
   p->status = GP_STATUS_IDLING;
   op->flag |= OP_IS_MODAL_CURSOR_REGION;
@@ -2440,7 +2441,7 @@ static void annotation_add_missing_events(bContext *C,
 }
 
 /* events handling during interactive drawing part of operator */
-static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
+static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
 {
   tGPsdata *p = op->customdata;
   /* default exit state - pass through to support MMB view nav, etc. */
@@ -2543,7 +2544,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
       if (sketch) {
         /* end stroke only, and then wait to resume painting soon */
         /* printf("\t\tGP - end stroke only\n"); */
-        gpencil_stroke_end(op);
+        annotation_stroke_end(op);
 
         /* If eraser mode is on, turn it off after the stroke finishes
          * NOTE: This just makes it nicer to work with drawing sessions
@@ -2562,7 +2563,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
              *       Just hiding this makes it seem like
              *       you can paint again...
              */
-            gpencil_draw_toggle_eraser_cursor(p, false);
+            annotation_draw_toggle_eraser_cursor(p, false);
           }
         }
 
@@ -2638,7 +2639,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
         /* Switch paintmode (temporarily if need be) based on which button was used
          * NOTE: This is to make it more convenient to erase strokes when using drawing sessions
          */
-        if ((event->type == RIGHTMOUSE) || gpencil_is_tablet_eraser_active(event)) {
+        if ((event->type == RIGHTMOUSE) || annotation_is_tablet_eraser_active(event)) {
           /* turn on eraser */
           p->paintmode = GP_PAINTMODE_ERASER;
         }
@@ -2647,10 +2648,10 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
           p->paintmode = RNA_enum_get(op->ptr, "mode");
         }
 
-        gpencil_draw_toggle_eraser_cursor(p, p->paintmode == GP_PAINTMODE_ERASER);
+        annotation_draw_toggle_eraser_cursor(p, p->paintmode == GP_PAINTMODE_ERASER);
 
         /* not painting, so start stroke (this should be mouse-button down) */
-        p = gpencil_stroke_begin(C, op);
+        p = annotation_stroke_begin(C, op);
 
         if (p->status == GP_STATUS_ERROR) {
           estate = OPERATOR_CANCELLED;
@@ -2734,26 +2735,26 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
   }
 
   /* gpencil modal operator stores area, which can be removed while using it (like fullscreen) */
-  if (0 == gpencil_area_exists(C, p->area)) {
+  if (0 == annotation_area_exists(C, p->area)) {
     estate = OPERATOR_CANCELLED;
   }
   else {
     /* update status indicators - cursor, header, etc. */
-    gpencil_draw_status_indicators(C, p);
+    annotation_draw_status_indicators(C, p);
     /* cursor may have changed outside our control - T44084 */
-    gpencil_draw_cursor_set(p);
+    annotation_draw_cursor_set(p);
   }
 
   /* process last operations before exiting */
   switch (estate) {
     case OPERATOR_FINISHED:
       /* one last flush before we're done */
-      gpencil_draw_exit(C, op);
+      annotation_draw_exit(C, op);
       WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
       break;
 
     case OPERATOR_CANCELLED:
-      gpencil_draw_exit(C, op);
+      annotation_draw_exit(C, op);
       break;
 
     case OPERATOR_RUNNING_MODAL | OPERATOR_PASS_THROUGH:
@@ -2812,11 +2813,11 @@ void GPENCIL_OT_annotate(wmOperatorType *ot)
   ot->description = "Make annotations on the active data";
 
   /* api callbacks */
-  ot->exec = gpencil_draw_exec;
-  ot->invoke = gpencil_draw_invoke;
-  ot->modal = gpencil_draw_modal;
-  ot->cancel = gpencil_draw_cancel;
-  ot->poll = gpencil_draw_poll;
+  ot->exec = annotation_draw_exec;
+  ot->invoke = annotation_draw_invoke;
+  ot->modal = annotation_draw_modal;
+  ot->cancel = annotation_draw_cancel;
+  ot->poll = annotation_draw_poll;
 
   /* flags */
   ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING;