diff options
author | julianeisel <julian_eisel@web.de> | 2014-12-26 22:00:52 +0300 |
---|---|---|
committer | julianeisel <julian_eisel@web.de> | 2014-12-26 22:00:52 +0300 |
commit | fd4720204399e16032574159699d5a26a250e6d5 (patch) | |
tree | ed6e0478eb56577ce3ab58a8a0dbb36aee9269b9 /source/blender/editors/gpencil/gpencil_paint.c | |
parent | 3253ed9e26dd146d11f5bf9ff1a2dce3dbf744ec (diff) |
GPencil: Picky whitespace cleanup
Diffstat (limited to 'source/blender/editors/gpencil/gpencil_paint.c')
-rw-r--r-- | source/blender/editors/gpencil/gpencil_paint.c | 538 |
1 files changed, 269 insertions, 269 deletions
diff --git a/source/blender/editors/gpencil/gpencil_paint.c b/source/blender/editors/gpencil/gpencil_paint.c index 67b0a67b6fb..b85e71de189 100644 --- a/source/blender/editors/gpencil/gpencil_paint.c +++ b/source/blender/editors/gpencil/gpencil_paint.c @@ -27,6 +27,7 @@ * \ingroup edgpencil */ + #include <stdio.h> #include <stddef.h> #include <stdlib.h> @@ -78,16 +79,16 @@ /* Temporary 'Stroke' Operation data */ typedef struct tGPsdata { Scene *scene; /* current scene from context */ - + wmWindow *win; /* window where painting originated */ ScrArea *sa; /* area where painting originated */ ARegion *ar; /* region where painting originated */ View2D *v2d; /* needed for GP_STROKE_2DSPACE */ rctf *subrect; /* for using the camera rect within the 3d view */ rctf subrect_data; - + GP_SpaceConversion gsc; /* settings to pass to gp_points_to_xy() */ - + PointerRNA ownerPtr; /* pointer to owner of gp-datablock */ bGPdata *gpd; /* gp-datablock layer comes from */ bGPDlayer *gpl; /* layer we're working on */ @@ -95,16 +96,16 @@ typedef struct tGPsdata { short status; /* current status of painting */ short paintmode; /* mode for painting */ - + int mval[2]; /* current mouse-position */ int mvalo[2]; /* previous recorded mouse-position */ - + float pressure; /* current stylus pressure */ float opressure; /* previous stylus pressure */ - + short radius; /* radius of influence for eraser */ short flags; /* flags that can get set during runtime */ - + /* These need to be doubles, as (at least under unix) they are in seconds since epoch, * float (and its 7 digits precision) is definitively not enough here! * double, with its 15 digits precision, ensures us millisecond precision for a few centuries at least. @@ -116,9 +117,9 @@ typedef struct tGPsdata { float imat[4][4]; /* inverted transformation matrix applying when converting coords from screen-space * to region space */ float mat[4][4]; - + float custom_color[4]; /* custom color - hack for enforcing a particular color for track/mask editing */ - + void *erasercursor; /* radial cursor data for drawing eraser */ } tGPsdata; @@ -194,7 +195,7 @@ static int gpencil_draw_poll(bContext *C) else { CTX_wm_operator_poll_msg_set(C, "Active region not set"); } - + return 0; } @@ -215,13 +216,13 @@ static void gp_get_3d_reference(tGPsdata *p, float vec[3]) { View3D *v3d = p->sa->spacedata.first; const float *fp = ED_view3d_cursor3d_get(p->scene, v3d); - + /* the reference point used depends on the owner... */ #if 0 /* XXX: disabled for now, since we can't draw relative to the owner yet */ if (p->ownerPtr.type == &RNA_Object) { Object *ob = (Object *)p->ownerPtr.data; - - /* active Object + + /* active Object * - use relative distance of 3D-cursor from object center */ sub_v3_v3v3(vec, fp, ob->loc); @@ -241,24 +242,24 @@ static bool gp_stroke_filtermval(tGPsdata *p, const int mval[2], int pmval[2]) { int dx = abs(mval[0] - pmval[0]); int dy = abs(mval[1] - pmval[1]); - + /* if buffer is empty, just let this go through (i.e. so that dots will work) */ if (p->gpd->sbuffer_size == 0) return true; - - /* check if mouse moved at least certain distance on both axes (best case) + + /* check if mouse moved at least certain distance on both axes (best case) * - aims to eliminate some jitter-noise from input when trying to draw straight lines freehand */ else if ((dx > MIN_MANHATTEN_PX) && (dy > MIN_MANHATTEN_PX)) return true; - - /* check if the distance since the last point is significant enough + + /* check if the distance since the last point is significant enough * - prevents points being added too densely * - distance here doesn't use sqrt to prevent slowness... we should still be safe from overflows though */ else if ((dx * dx + dy * dy) > MIN_EUCLIDEAN_PX * MIN_EUCLIDEAN_PX) return true; - + /* mouse 'didn't move' */ else return false; @@ -269,7 +270,7 @@ static bool gp_stroke_filtermval(tGPsdata *p, const int mval[2], int pmval[2]) static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3], float *depth) { bGPdata *gpd = p->gpd; - + /* in 3d-space - pt->x/y/z are 3 side-by-side floats */ if (gpd->sbuffer_sflag & GP_STROKE_3DSPACE) { if (gpencil_project_check(p) && (ED_view3d_autodist_simple(p->ar, mval, out, 0, depth))) { @@ -282,7 +283,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3] float rvec[3], dvec[3]; float mval_f[2] = {UNPACK2(mval)}; float zfac; - + /* Current method just converts each point in screen-coordinates to * 3D-coordinates using the 3D-cursor as reference. In general, this * works OK, but it could of course be improved. @@ -291,7 +292,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3] * - investigate using nearest point(s) on a previous stroke as * reference point instead or as offset, for easier stroke matching */ - + gp_get_3d_reference(p, rvec); zfac = ED_view3d_calc_zfac(p->ar->regiondata, rvec, NULL); @@ -305,13 +306,13 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3] } } } - + /* 2d - on 'canvas' (assume that p->v2d is set) */ else if ((gpd->sbuffer_sflag & GP_STROKE_2DSPACE) && (p->v2d)) { UI_view2d_region_to_view(p->v2d, mval[0], mval[1], &out[0], &out[1]); mul_v3_m4v3(out, p->imat, out); } - + /* 2d - relative to screen (viewport area) */ else { if (p->subrect == NULL) { /* normal 3D view */ @@ -337,26 +338,26 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, if (gpd->sbuffer_size == 0) { /* first point in buffer (start point) */ pt = (tGPspoint *)(gpd->sbuffer); - + /* store settings */ copy_v2_v2_int(&pt->x, mval); pt->pressure = pressure; pt->time = (float)(curtime - p->inittime); - + /* increment buffer size */ gpd->sbuffer_size++; } else { - /* normally, we just reset the endpoint to the latest value + /* normally, we just reset the endpoint to the latest value * - assume that pointers for this are always valid... */ pt = ((tGPspoint *)(gpd->sbuffer) + 1); - + /* store settings */ copy_v2_v2_int(&pt->x, mval); pt->pressure = pressure; pt->time = (float)(curtime - p->inittime); - + /* if this is just the second point we've added, increment the buffer size * so that it will be drawn properly... * otherwise, just leave it alone, otherwise we get problems @@ -364,7 +365,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, if (gpd->sbuffer_size != 2) gpd->sbuffer_size = 2; } - + /* can keep carrying on this way :) */ return GP_STROKEADD_NORMAL; } @@ -372,18 +373,18 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, /* check if still room in buffer */ if (gpd->sbuffer_size >= GP_STROKE_BUFFER_MAX) return GP_STROKEADD_OVERFLOW; - + /* get pointer to destination point */ pt = ((tGPspoint *)(gpd->sbuffer) + gpd->sbuffer_size); - + /* store settings */ copy_v2_v2_int(&pt->x, mval); pt->pressure = pressure; pt->time = (float)(curtime - p->inittime); - + /* increment counters */ gpd->sbuffer_size++; - + /* check if another operation can still occur */ if (gpd->sbuffer_size == GP_STROKE_BUFFER_MAX) return GP_STROKEADD_FULL; @@ -393,12 +394,12 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, else if (p->paintmode == GP_PAINTMODE_DRAW_POLY) { /* get pointer to destination point */ pt = (tGPspoint *)(gpd->sbuffer); - + /* store settings */ copy_v2_v2_int(&pt->x, mval); pt->pressure = pressure; pt->time = (float)(curtime - p->inittime); - + /* if there's stroke for this poly line session add (or replace last) point * to stroke. This allows to draw lines more interactively (see new segment * during mouse slide, e.g.) @@ -406,15 +407,15 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, if (gp_stroke_added_check(p)) { bGPDstroke *gps = p->gpf->strokes.last; bGPDspoint *pts; - + /* first time point is adding to temporary buffer -- need to allocate new point in stroke */ if (gpd->sbuffer_size == 0) { gps->points = MEM_reallocN(gps->points, sizeof(bGPDspoint) * (gps->totpoints + 1)); gps->totpoints++; } - + pts = &gps->points[gps->totpoints - 1]; - + /* special case for poly lines: normally, * depth is needed only when creating new stroke from buffer, * but poly lines are converting to stroke instantly, @@ -422,26 +423,26 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, */ if (gpencil_project_check(p)) { View3D *v3d = p->sa->spacedata.first; - + view3d_region_operator_needs_opengl(p->win, p->ar); ED_view3d_autodist_init(p->scene, p->ar, v3d, (p->gpd->flag & GP_DATA_DEPTH_STROKE) ? 1 : 0); } - + /* convert screen-coordinates to appropriate coordinates (and store them) */ gp_stroke_convertcoords(p, &pt->x, &pts->x, NULL); - + /* copy pressure and time */ pts->pressure = pt->pressure; pts->time = pt->time; } - + /* increment counters */ if (gpd->sbuffer_size == 0) gpd->sbuffer_size++; - + return GP_STROKEADD_NORMAL; } - + /* return invalid state for now... */ return GP_STROKEADD_INVALID; } @@ -452,21 +453,21 @@ static void gp_stroke_smooth(tGPsdata *p) bGPdata *gpd = p->gpd; tGPspoint *spt, tmp_spt[3]; int i = 0, cmx = gpd->sbuffer_size; - + /* only smooth if smoothing is enabled, and we're not doing a straight line */ if (!(U.gp_settings & GP_PAINT_DOSMOOTH) || ELEM(p->paintmode, GP_PAINTMODE_DRAW_STRAIGHT, GP_PAINTMODE_DRAW_POLY)) return; - + /* don't try if less than 2 points in buffer */ if ((cmx <= 2) || (gpd->sbuffer == NULL)) return; - - /* Calculate smoothing coordinates using weighted-averages + + /* Calculate smoothing coordinates using weighted-averages * WARNING: we do NOT smooth first and last points (to avoid shrinkage) */ spt = (tGPspoint *)gpd->sbuffer; - - /* This (tmp_spt) small array stores the last two points' original coordinates, + + /* This (tmp_spt) small array stores the last two points' original coordinates, * as we don't want to use already averaged ones! It is used as a cyclic buffer... */ tmp_spt[0] = *spt; @@ -476,16 +477,16 @@ static void gp_stroke_smooth(tGPsdata *p) const tGPspoint *pa = (i - 1 > 0) ? (&tmp_spt[(i - 2) % 3]) : (pb); const tGPspoint *pd = pc + 1; const tGPspoint *pe = (i + 2 < cmx) ? (pc + 2) : (pd); - + /* Store current point's original state for the two next points! */ tmp_spt[i % 3] = *spt; - + spt->x = (int)(0.1 * pa->x + 0.2 * pb->x + 0.4 * pc->x + 0.2 * pd->x + 0.1 * pe->x); spt->y = (int)(0.1 * pa->y + 0.2 * pb->y + 0.4 * pc->y + 0.2 * pd->y + 0.1 * pe->y); } } -/* simplify a stroke (in buffer) before storing it +/* simplify a stroke (in buffer) before storing it * - applies a reverse Chaikin filter * - code adapted from etch-a-ton branch (editarmature_sketch.c) */ @@ -496,23 +497,23 @@ static void gp_stroke_simplify(tGPsdata *p) short num_points = gpd->sbuffer_size; short flag = gpd->sbuffer_sflag; short i, j; - + /* only simplify if simplification is enabled, and we're not doing a straight line */ if (!(U.gp_settings & GP_PAINT_DOSIMPLIFY) || (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT)) return; - + /* don't simplify if less than 4 points in buffer */ if ((num_points <= 4) || (old_points == NULL)) return; - - /* clear buffer (but don't free mem yet) so that we can write to it + + /* clear buffer (but don't free mem yet) so that we can write to it * - firstly set sbuffer to NULL, so a new one is allocated * - secondly, reset flag after, as it gets cleared auto */ gpd->sbuffer = NULL; gp_session_validatebuffer(p); gpd->sbuffer_sflag = flag; - + /* macro used in loop to get position of new point * - used due to the mixture of datatypes in use here */ @@ -523,39 +524,39 @@ static void gp_stroke_simplify(tGPsdata *p) pressure += old_points[offs].pressure * sfac; \ time += old_points[offs].time * sfac; \ } (void)0 - + /* XXX Here too, do not lose start and end points! */ gp_stroke_addpoint(p, &old_points->x, old_points->pressure, p->inittime + (double)old_points->time); for (i = 0, j = 0; i < num_points; i++) { if (i - j == 3) { float co[2], pressure, time; int mco[2]; - + /* initialize values */ co[0] = 0.0f; co[1] = 0.0f; pressure = 0.0f; time = 0.0f; - + /* using macro, calculate new point */ GP_SIMPLIFY_AVPOINT(j, -0.25f); GP_SIMPLIFY_AVPOINT(j + 1, 0.75f); GP_SIMPLIFY_AVPOINT(j + 2, 0.75f); GP_SIMPLIFY_AVPOINT(j + 3, -0.25f); - + /* set values for adding */ mco[0] = (int)co[0]; mco[1] = (int)co[1]; - + /* ignore return values on this... assume to be ok for now */ gp_stroke_addpoint(p, mco, pressure, p->inittime + (double)time); - + j += 2; } } gp_stroke_addpoint(p, &old_points[num_points - 1].x, old_points[num_points - 1].pressure, p->inittime + (double)old_points[num_points - 1].time); - + /* free old buffer */ MEM_freeN(old_points); } @@ -571,22 +572,22 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) int i, totelem; /* since strokes are so fine, when using their depth we need a margin otherwise they might get missed */ int depth_margin = (p->gpd->flag & GP_DATA_DEPTH_STROKE) ? 4 : 0; - - /* get total number of points to allocate space for + + /* get total number of points to allocate space for * - drawing straight-lines only requires the endpoints */ if (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT) totelem = (gpd->sbuffer_size >= 2) ? 2 : gpd->sbuffer_size; else totelem = gpd->sbuffer_size; - + /* exit with error if no valid points from this stroke */ if (totelem == 0) { if (G.debug & G_DEBUG) printf("Error: No valid points in stroke buffer to convert (tot=%d)\n", gpd->sbuffer_size); return; } - + /* special case for poly line -- for already added stroke during session * coordinates are getting added to stroke immediately to allow more * interactive behavior @@ -596,46 +597,46 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) return; } } - + /* allocate memory for a new stroke */ gps = MEM_callocN(sizeof(bGPDstroke), "gp_stroke"); - + /* copy appropriate settings for stroke */ gps->totpoints = totelem; gps->thickness = p->gpl->thickness; gps->flag = gpd->sbuffer_sflag; gps->inittime = p->inittime; - + /* allocate enough memory for a continuous array for storage points */ gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points"); - + /* set pointer to first non-initialized point */ pt = gps->points + (gps->totpoints - totelem); - + /* copy points from the buffer to the stroke */ if (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT) { /* straight lines only -> only endpoints */ { /* first point */ ptc = gpd->sbuffer; - + /* convert screen-coordinates to appropriate coordinates (and store them) */ gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - + /* copy pressure and time */ pt->pressure = ptc->pressure; pt->time = ptc->time; - + pt++; } - + if (totelem == 2) { /* last point if applicable */ ptc = ((tGPspoint *)gpd->sbuffer) + (gpd->sbuffer_size - 1); - + /* convert screen-coordinates to appropriate coordinates (and store them) */ gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - + /* copy pressure and time */ pt->pressure = ptc->pressure; pt->time = ptc->time; @@ -644,28 +645,28 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) else if (p->paintmode == GP_PAINTMODE_DRAW_POLY) { /* first point */ ptc = gpd->sbuffer; - + /* convert screen-coordinates to appropriate coordinates (and store them) */ gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - + /* copy pressure and time */ pt->pressure = ptc->pressure; pt->time = ptc->time; } else { float *depth_arr = NULL; - + /* get an array of depths, far depths are blended */ if (gpencil_project_check(p)) { int mval[2], mval_prev[2] = {0}; int interp_depth = 0; int found_depth = 0; - + depth_arr = MEM_mallocN(sizeof(float) * gpd->sbuffer_size, "depth_points"); - + for (i = 0, ptc = gpd->sbuffer; i < gpd->sbuffer_size; i++, ptc++, pt++) { copy_v2_v2_int(mval, &ptc->x); - + if ((ED_view3d_autodist_depth(p->ar, mval, depth_margin, depth_arr + i) == 0) && (i && (ED_view3d_autodist_depth_seg(p->ar, mval, mval_prev, depth_margin + 1, depth_arr + i) == 0))) { @@ -674,10 +675,10 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) else { found_depth = true; } - + copy_v2_v2_int(mval_prev, mval); } - + if (found_depth == false) { /* eeh... not much we can do.. :/, ignore depth in this case, use the 3D cursor */ for (i = gpd->sbuffer_size - 1; i >= 0; i--) @@ -688,49 +689,49 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) /* remove all info between the valid endpoints */ int first_valid = 0; int last_valid = 0; - + for (i = 0; i < gpd->sbuffer_size; i++) { if (depth_arr[i] != FLT_MAX) break; } first_valid = i; - + for (i = gpd->sbuffer_size - 1; i >= 0; i--) { if (depth_arr[i] != FLT_MAX) break; } last_valid = i; - + /* invalidate non-endpoints, so only blend between first and last */ for (i = first_valid + 1; i < last_valid; i++) depth_arr[i] = FLT_MAX; - + interp_depth = true; } - + if (interp_depth) { interp_sparse_array(depth_arr, gpd->sbuffer_size, FLT_MAX); } } } - - + + pt = gps->points; - + /* convert all points (normal behavior) */ for (i = 0, ptc = gpd->sbuffer; i < gpd->sbuffer_size && 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); - + /* copy pressure and time */ pt->pressure = ptc->pressure; pt->time = ptc->time; } - + if (depth_arr) MEM_freeN(depth_arr); } - + /* add stroke to frame */ BLI_addtail(&p->gpf->strokes, gps); gp_stroke_added_enable(p); @@ -743,38 +744,38 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i) { bGPDspoint *pt_tmp = gps->points; bGPDstroke *gsn = NULL; - + /* if stroke only had two points, get rid of stroke */ if (gps->totpoints == 2) { /* free stroke points, then stroke */ MEM_freeN(pt_tmp); BLI_freelinkN(&gpf->strokes, gps); - + /* nothing left in stroke, so stop */ return 1; } - + /* if last segment, just remove segment from the stroke */ else if (i == gps->totpoints - 2) { /* allocate new points array, and assign most of the old stroke there */ gps->totpoints--; gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points"); memcpy(gps->points, pt_tmp, sizeof(bGPDspoint) * gps->totpoints); - + /* free temp buffer */ MEM_freeN(pt_tmp); - + /* nothing left in stroke, so stop */ return 1; } - + /* if first segment, just remove segment from the stroke */ else if (i == 0) { /* allocate new points array, and assign most of the old stroke there */ gps->totpoints--; gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points"); memcpy(gps->points, pt_tmp + 1, sizeof(bGPDspoint) * gps->totpoints); - + /* We must adjust timings! * Each point's timing data is a delta from stroke's inittime, so as we erase the first * point of the stroke, we have to offset this inittime and all remaining points' delta values. @@ -785,33 +786,33 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i) bGPDspoint *pts; float delta = pt_tmp[1].time; int j; - + gps->inittime += (double)delta; - + pts = gps->points; for (j = 0; j < gps->totpoints; j++, pts++) { pts->time -= delta; } } - + /* free temp buffer */ MEM_freeN(pt_tmp); - + /* no break here, as there might still be stuff to remove in this stroke */ return 0; } - + /* segment occurs in 'middle' of stroke, so split */ else { /* duplicate stroke, and assign 'later' data to that stroke */ gsn = MEM_dupallocN(gps); gsn->prev = gsn->next = NULL; BLI_insertlinkafter(&gpf->strokes, gps, gsn); - + gsn->totpoints = gps->totpoints - i; gsn->points = MEM_callocN(sizeof(bGPDspoint) * gsn->totpoints, "gp_stroke_points"); memcpy(gsn->points, pt_tmp + i, sizeof(bGPDspoint) * gsn->totpoints); - + /* We must adjust timings of this new stroke! * Each point's timing data is a delta from stroke's inittime, so as we erase the first * point of the stroke, we have to offset this inittime and all remaing points' delta values. @@ -822,23 +823,23 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i) bGPDspoint *pts; float delta = pt_tmp[i].time; int j; - + gsn->inittime += (double)delta; - + pts = gsn->points; for (j = 0; j < gsn->totpoints; j++, pts++) { pts->time -= delta; } } - + /* adjust existing stroke */ gps->totpoints = i; gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points"); memcpy(gps->points, pt_tmp, sizeof(bGPDspoint) * i); - + /* free temp buffer */ MEM_freeN(pt_tmp); - + /* nothing left in stroke, so stop */ return 1; } @@ -855,8 +856,7 @@ static float view3d_point_depth(const RegionView3D *rv3d, const float co[3]) } } -static bool gp_stroke_eraser_is_occluded(tGPsdata *p, - const bGPDspoint *pt, const int x, const int y) +static bool gp_stroke_eraser_is_occluded(tGPsdata *p, const bGPDspoint *pt, const int x, const int y) { if ((p->sa->spacetype == SPACE_VIEW3D) && (p->flags & GP_PAINTFLAG_V3D_ERASER_DEPTH)) @@ -887,16 +887,16 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p, bGPDspoint *pt1, *pt2; int x0 = 0, y0 = 0, x1 = 0, y1 = 0; int i; - + if (gps->totpoints == 0) { /* just free stroke */ - if (gps->points) + if (gps->points) MEM_freeN(gps->points); BLI_freelinkN(&gpf->strokes, gps); } else if (gps->totpoints == 1) { gp_point_to_xy(&p->gsc, gps, gps->points, &x0, &y0); - + /* do boundbox check first */ if ((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(rect, x0, y0)) { /* only check if point is inside */ @@ -908,17 +908,17 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p, } } else { - /* loop over the points in the stroke, checking for intersections + /* loop over the points in the stroke, checking for intersections * - an intersection will require the stroke to be split */ for (i = 0; (i + 1) < gps->totpoints; i++) { /* get points to work with */ pt1 = gps->points + i; pt2 = gps->points + i + 1; - + gp_point_to_xy(&p->gsc, gps, pt1, &x0, &y0); gp_point_to_xy(&p->gsc, gps, pt2, &x1, &y1); - + /* check that point segment of the boundbox of the eraser stroke */ if (((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(rect, x0, y0)) || ((!ELEM(V2D_IS_CLIPPED, x1, y1)) && BLI_rcti_isect_pt(rect, x1, y1))) @@ -947,7 +947,7 @@ static void gp_stroke_doeraser(tGPsdata *p) bGPDframe *gpf = p->gpf; bGPDstroke *gps, *gpn; rcti rect; - + /* rect is rectangle of eraser */ rect.xmin = p->mval[0] - p->radius; rect.ymin = p->mval[1] - p->radius; @@ -977,7 +977,7 @@ static void gp_stroke_doeraser(tGPsdata *p) static void gp_session_validatebuffer(tGPsdata *p) { bGPdata *gpd = p->gpd; - + /* clear memory of buffer (or allocate it if starting a new session) */ if (gpd->sbuffer) { /* printf("\t\tGP - reset sbuffer\n"); */ @@ -987,10 +987,10 @@ static void gp_session_validatebuffer(tGPsdata *p) /* printf("\t\tGP - allocate sbuffer\n"); */ gpd->sbuffer = MEM_callocN(sizeof(tGPspoint) * GP_STROKE_BUFFER_MAX, "gp_session_strokebuffer"); } - + /* reset indices */ gpd->sbuffer_size = 0; - + /* reset flags */ gpd->sbuffer_sflag = 0; @@ -1004,7 +1004,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) bGPdata **gpd_ptr = NULL; ScrArea *curarea = CTX_wm_area(C); ARegion *ar = CTX_wm_region(C); - + /* make sure the active view (at the starting time) is a 3d-view */ if (curarea == NULL) { p->status = GP_STATUS_ERROR; @@ -1012,27 +1012,27 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) printf("Error: No active view for painting\n"); return 0; } - + /* pass on current scene and window */ p->scene = CTX_data_scene(C); p->win = CTX_wm_window(C); unit_m4(p->imat); unit_m4(p->mat); - + switch (curarea->spacetype) { /* supported views first */ case SPACE_VIEW3D: { /* View3D *v3d = curarea->spacedata.first; */ /* RegionView3D *rv3d = ar->regiondata; */ - - /* set current area + + /* set current area * - must verify that region data is 3D-view (and not something else) */ p->sa = curarea; p->ar = ar; - + if (ar->regiondata == NULL) { p->status = GP_STATUS_ERROR; if (G.debug & G_DEBUG) @@ -1044,7 +1044,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) case SPACE_NODE: { /* SpaceNode *snode = curarea->spacedata.first; */ - + /* set current area */ p->sa = curarea; p->ar = ar; @@ -1054,12 +1054,12 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) case SPACE_SEQ: { SpaceSeq *sseq = curarea->spacedata.first; - + /* set current area */ p->sa = curarea; p->ar = ar; p->v2d = &ar->v2d; - + /* check that gpencil data is allowed to be drawn */ if (sseq->mainb == SEQ_DRAW_SEQUENCE) { p->status = GP_STATUS_ERROR; @@ -1072,7 +1072,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) case SPACE_IMAGE: { /* SpaceImage *sima = curarea->spacedata.first; */ - + /* set the current area */ p->sa = curarea; p->ar = ar; @@ -1082,30 +1082,30 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) case SPACE_CLIP: { SpaceClip *sc = curarea->spacedata.first; - + /* set the current area */ p->sa = curarea; p->ar = ar; p->v2d = &ar->v2d; - + invert_m4_m4(p->imat, sc->unistabmat); - + /* custom color for new layer */ p->custom_color[0] = 1.0f; p->custom_color[1] = 0.0f; p->custom_color[2] = 0.5f; p->custom_color[3] = 0.9f; - + if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) { MovieClip *clip = ED_space_clip_get_clip(sc); int framenr = ED_space_clip_get_clip_frame_number(sc); MovieTrackingTrack *track = BKE_tracking_track_get_active(&clip->tracking); MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr); - + p->imat[3][0] -= marker->pos[0]; p->imat[3][1] -= marker->pos[1]; } - + invert_m4_m4(p->mat, p->imat); copy_m4_m4(p->gsc.mat, p->mat); break; @@ -1119,7 +1119,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) return 0; } } - + /* get gp-data */ gpd_ptr = ED_gpencil_data_get_pointers(C, &p->ownerPtr); if (gpd_ptr == NULL) { @@ -1134,17 +1134,17 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) *gpd_ptr = gpencil_data_addnew("GPencil"); p->gpd = *gpd_ptr; } - + if (ED_gpencil_session_active() == 0) { /* initialize undo stack, * also, existing undo stack would make buffer drawn */ gpencil_undo_init(p->gpd); } - + /* clear out buffer (stored in gp-data), in case something contaminated it */ gp_session_validatebuffer(p); - + return 1; } @@ -1157,7 +1157,7 @@ static tGPsdata *gp_session_initpaint(bContext *C) p = MEM_callocN(sizeof(tGPsdata), "GPencil Drawing Data"); gp_session_initdata(C, p); - + /* return context data for running paint operator */ return p; } @@ -1166,18 +1166,18 @@ static tGPsdata *gp_session_initpaint(bContext *C) static void gp_session_cleanup(tGPsdata *p) { bGPdata *gpd = (p) ? p->gpd : NULL; - + /* error checking */ if (gpd == NULL) return; - + /* free stroke buffer */ if (gpd->sbuffer) { /* printf("\t\tGP - free sbuffer\n"); */ MEM_freeN(gpd->sbuffer); gpd->sbuffer = NULL; } - + /* clear flags */ gpd->sbuffer_size = 0; gpd->sbuffer_sflag = 0; @@ -1186,12 +1186,12 @@ static void gp_session_cleanup(tGPsdata *p) /* init new stroke */ static void gp_paint_initstroke(tGPsdata *p, short paintmode) -{ +{ /* get active layer (or add a new one if non-existent) */ p->gpl = gpencil_layer_getactive(p->gpd); if (p->gpl == NULL) { p->gpl = gpencil_layer_addnew(p->gpd, "GP_Layer", 1); - + if (p->custom_color[3]) copy_v3_v3(p->gpl->color, p->custom_color); } @@ -1201,7 +1201,7 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) printf("Error: Cannot paint on locked layer\n"); return; } - + /* get active frame (add a new one if not matching frame) */ p->gpf = gpencil_layer_getframe(p->gpl, p->scene->r.cfra, 1); if (p->gpf == NULL) { @@ -1212,7 +1212,7 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) } else p->gpf->flag |= GP_FRAME_PAINT; - + /* set 'eraser' for this stroke if using eraser */ p->paintmode = paintmode; if (p->paintmode == GP_PAINTMODE_ERASER) { @@ -1228,14 +1228,14 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) /* set 'initial run' flag, which is only used to denote when a new stroke is starting */ p->flags |= GP_PAINTFLAG_FIRSTRUN; - + /* when drawing in the camera view, in 2D space, set the subrect */ if (!(p->gpd->flag & GP_DATA_VIEWALIGN)) { if (p->sa->spacetype == SPACE_VIEW3D) { View3D *v3d = p->sa->spacedata.first; RegionView3D *rv3d = p->ar->regiondata; - + /* for camera view set the subrect */ if (rv3d->persp == RV3D_CAMOB) { ED_view3d_calc_camera_border(p->scene, p->ar, v3d, rv3d, &p->subrect_data, true); /* no shift */ @@ -1243,21 +1243,21 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) } } } - + /* init stroke point space-conversion settings... */ p->gsc.gpd = p->gpd; p->gsc.gpl = p->gpl; - + p->gsc.sa = p->sa; p->gsc.ar = p->ar; p->gsc.v2d = p->v2d; - + p->gsc.subrect_data = p->subrect_data; p->gsc.subrect = p->subrect; - + copy_m4_m4(p->gsc.mat, p->mat); - - + + /* check if points will need to be made in view-aligned space */ if (p->gpd->flag & GP_DATA_VIEWALIGN) { switch (p->sa->spacetype) { @@ -1279,7 +1279,7 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) case SPACE_IMAGE: { SpaceImage *sima = (SpaceImage *)p->sa->spacedata.first; - + /* only set these flags if the image editor doesn't have an image active, * otherwise user will be confused by strokes not appearing after they're drawn * @@ -1307,29 +1307,29 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) /* finish off a stroke (clears buffer, but doesn't finish the paint operation) */ static void gp_paint_strokeend(tGPsdata *p) { - /* for surface sketching, need to set the right OpenGL context stuff so that + /* 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)) { View3D *v3d = p->sa->spacedata.first; - + /* need to restore the original projection settings before packing up */ view3d_region_operator_needs_opengl(p->win, p->ar); ED_view3d_autodist_init(p->scene, p->ar, v3d, (p->gpd->flag & GP_DATA_DEPTH_STROKE) ? 1 : 0); } - + /* check if doing eraser or not */ if ((p->gpd->sbuffer_sflag & GP_STROKE_ERASER) == 0) { /* smooth stroke before transferring? */ gp_stroke_smooth(p); - + /* simplify stroke before transferring? */ gp_stroke_simplify(p); - + /* transfer stroke to frame */ gp_stroke_newfrombuffer(p); } - + /* clean up buffer now */ gp_session_validatebuffer(p); } @@ -1344,7 +1344,7 @@ static void gp_paint_cleanup(tGPsdata *p) /* finish off a stroke */ gp_paint_strokeend(p); } - + /* "unlock" frame */ if (p->gpf) p->gpf->flag &= ~GP_FRAME_PAINT; @@ -1356,15 +1356,15 @@ static void gp_paint_cleanup(tGPsdata *p) static void gpencil_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr) { tGPsdata *p = (tGPsdata *)p_ptr; - + if (p->paintmode == GP_PAINTMODE_ERASER) { glPushMatrix(); - + glTranslatef((float)x, (float)y, 0.0f); - + glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); - + glColor4ub(255, 100, 100, 20); glutil_draw_filled_arc(0.0, M_PI * 2.0, p->radius, 40); @@ -1372,11 +1372,11 @@ static void gpencil_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr) glColor4ub(255, 100, 100, 200); glutil_draw_lined_arc(0.0, M_PI * 2.0, p->radius, 40); - + setlinestyle(0); glDisable(GL_BLEND); glDisable(GL_LINE_SMOOTH); - + glPopMatrix(); } } @@ -1391,7 +1391,7 @@ static void gpencil_draw_toggle_eraser_cursor(bContext *C, tGPsdata *p, short en } else if (enable) { /* enable cursor */ - p->erasercursor = WM_paint_cursor_activate(CTX_wm_manager(C), + p->erasercursor = WM_paint_cursor_activate(CTX_wm_manager(C), NULL, /* XXX */ gpencil_draw_eraser, p); } @@ -1403,33 +1403,33 @@ static void gpencil_draw_toggle_eraser_cursor(bContext *C, tGPsdata *p, short en static void gpencil_draw_exit(bContext *C, wmOperator *op) { tGPsdata *p = op->customdata; - + /* clear undo stack */ gpencil_undo_finish(); - + /* restore cursor to indicate end of drawing */ WM_cursor_modal_restore(CTX_wm_window(C)); - + /* don't assume that operator data exists at all */ if (p) { /* 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(C, p, false); - + /* if successful, store the new eraser size to be used again next time */ if (p->status == GP_STATUS_DONE) U.gp_eraser = p->radius; } - + /* cleanup */ gp_paint_cleanup(p); gp_session_cleanup(p); - + /* finally, free the temp data */ MEM_freeN(p); } - + op->customdata = NULL; } @@ -1446,7 +1446,7 @@ static int gpencil_draw_init(bContext *C, wmOperator *op) { tGPsdata *p; int paintmode = RNA_enum_get(op->ptr, "mode"); - + /* check context */ p = op->customdata = gp_session_initpaint(C); if ((p == NULL) || (p->status == GP_STATUS_ERROR)) { @@ -1454,17 +1454,17 @@ static int gpencil_draw_init(bContext *C, wmOperator *op) gpencil_draw_exit(C, op); return 0; } - + /* init painting data */ gp_paint_initstroke(p, paintmode); if (p->status == GP_STATUS_ERROR) { gpencil_draw_exit(C, op); return 0; } - + /* radius for eraser circle is defined in userprefs now */ p->radius = U.gp_eraser; - + /* everything is now setup ok */ return 1; } @@ -1482,7 +1482,7 @@ static void gpencil_draw_status_indicators(tGPsdata *p) if (GPENCIL_SKETCH_SESSIONS_ON(p->scene)) ED_area_headerprint(p->sa, IFACE_("Grease Pencil: Drawing/erasing stroke... Release to end stroke")); break; - + case GP_STATUS_IDLING: /* print status info */ switch (p->paintmode) { @@ -1498,13 +1498,13 @@ static void gpencil_draw_status_indicators(tGPsdata *p) ED_area_headerprint(p->sa, IFACE_("Grease Pencil Freehand Session: Hold and drag LMB to draw | " "ESC/Enter to end")); break; - + default: /* unhandled future cases */ ED_area_headerprint(p->sa, IFACE_("Grease Pencil Session: ESC/Enter to end")); break; } break; - + case GP_STATUS_ERROR: case GP_STATUS_DONE: /* clear status string */ @@ -1522,7 +1522,7 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p) if (p->paintmode == GP_PAINTMODE_ERASER) { /* do 'live' erasing now */ gp_stroke_doeraser(p); - + /* store used values */ p->mvalo[0] = p->mval[0]; p->mvalo[1] = p->mval[1]; @@ -1532,14 +1532,14 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p) else if (gp_stroke_filtermval(p, p->mval, p->mvalo)) { /* try to add point */ short ok = gp_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); /* And start a new one!!! Else, projection errors! */ gp_paint_initstroke(p, p->paintmode); - + /* start a new stroke, starting from previous point */ /* XXX Must manually reset inittime... */ /* XXX We only need to reuse previous point if overflow! */ @@ -1556,12 +1556,12 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p) /* the painting operation cannot continue... */ BKE_report(op->reports, RPT_ERROR, "Cannot paint stroke"); p->status = GP_STATUS_ERROR; - + if (G.debug & G_DEBUG) printf("Error: Grease-Pencil Paint - Add Point Invalid\n"); return; } - + /* store used values */ p->mvalo[0] = p->mval[0]; p->mvalo[1] = p->mval[1]; @@ -1577,57 +1577,57 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event) PointerRNA itemptr; float mousef[2]; int tablet = 0; - + /* convert from window-space to area-space mouse coordinates * NOTE: float to ints conversions, +1 factor is probably used to ensure a bit more accurate rounding... */ p->mval[0] = event->mval[0] + 1; p->mval[1] = event->mval[1] + 1; p->curtime = PIL_check_seconds_timer(); - + /* handle pressure sensitivity (which is supplied by tablets) */ if (event->tablet_data) { wmTabletData *wmtab = event->tablet_data; - + tablet = (wmtab->Active != EVT_TABLET_NONE); p->pressure = wmtab->Pressure; - + /* if (wmtab->Active == EVT_TABLET_ERASER) */ /* TODO... this should get caught by the keymaps which call drawing in the first place */ } else p->pressure = 1.0f; - + /* fill in stroke data (not actually used directly by gpencil_draw_apply) */ RNA_collection_add(op->ptr, "stroke", &itemptr); - + mousef[0] = p->mval[0]; mousef[1] = p->mval[1]; RNA_float_set_array(&itemptr, "mouse", mousef); RNA_float_set(&itemptr, "pressure", p->pressure); RNA_boolean_set(&itemptr, "is_start", (p->flags & GP_PAINTFLAG_FIRSTRUN)); - + /* special exception for start of strokes (i.e. maybe for just a dot) */ if (p->flags & GP_PAINTFLAG_FIRSTRUN) { p->flags &= ~GP_PAINTFLAG_FIRSTRUN; - + p->mvalo[0] = p->mval[0]; p->mvalo[1] = p->mval[1]; p->opressure = p->pressure; p->inittime = p->ocurtime = p->curtime; - + /* special exception here for too high pressure values on first touch in * windows for some tablets, then we just skip first touch... */ if (tablet && (p->pressure >= 0.99f)) return; } - + RNA_float_set(&itemptr, "time", p->curtime - p->inittime); - + /* apply the current latest drawing point */ gpencil_draw_apply(op, p); - + /* force refresh */ ED_region_tag_redraw(p->ar); /* just active area for now, since doing whole screen is too slow */ } @@ -1638,9 +1638,9 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event) static int gpencil_draw_exec(bContext *C, wmOperator *op) { tGPsdata *p = NULL; - + /* printf("GPencil - Starting Re-Drawing\n"); */ - + /* try to initialize context data needed while drawing */ if (!gpencil_draw_init(C, op)) { if (op->customdata) MEM_freeN(op->customdata); @@ -1649,25 +1649,25 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op) } else p = op->customdata; - + /* printf("\tGP - Start redrawing stroke\n"); */ - + /* loop over the stroke RNA elements recorded (i.e. progress of mouse movement), * setting the relevant values in context at each step, then applying */ RNA_BEGIN (op->ptr, itemptr, "stroke") { float mousef[2]; - + /* printf("\t\tGP - stroke elem\n"); */ - + /* get relevant data for this point from stroke */ RNA_float_get_array(&itemptr, "mouse", mousef); p->mval[0] = (int)mousef[0]; p->mval[1] = (int)mousef[1]; p->pressure = RNA_float_get(&itemptr, "pressure"); p->curtime = (double)RNA_float_get(&itemptr, "time") + p->inittime; - + if (RNA_boolean_get(&itemptr, "is_start")) { /* if first-run flag isn't set already (i.e. not true first stroke), * then we must terminate the previous one first before continuing @@ -1678,30 +1678,30 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op) gp_paint_initstroke(p, p->paintmode); } } - + /* if first run, set previous data too */ if (p->flags & GP_PAINTFLAG_FIRSTRUN) { p->flags &= ~GP_PAINTFLAG_FIRSTRUN; - + p->mvalo[0] = p->mval[0]; p->mvalo[1] = p->mval[1]; p->opressure = p->pressure; p->ocurtime = p->curtime; } - + /* apply this data as necessary now (as per usual) */ gpencil_draw_apply(op, p); } RNA_END; - + /* printf("\tGP - done\n"); */ - + /* cleanup */ gpencil_draw_exit(C, op); - + /* refreshes */ WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); - + /* done */ return OPERATOR_FINISHED; } @@ -1713,13 +1713,13 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event { tGPsdata *p = NULL; wmWindow *win = CTX_wm_window(C); - + if (G.debug & G_DEBUG) printf("GPencil - Starting Drawing\n"); - + /* try to initialize context data needed while drawing */ if (!gpencil_draw_init(C, op)) { - if (op->customdata) + if (op->customdata) MEM_freeN(op->customdata); if (G.debug & G_DEBUG) printf("\tGP - no valid data\n"); @@ -1737,19 +1737,19 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event if (p->paintmode == GP_PAINTMODE_ERASER) { gpencil_draw_toggle_eraser_cursor(C, p, true); } - + /* set cursor */ if (p->paintmode == GP_PAINTMODE_ERASER) WM_cursor_modal_set(win, BC_CROSSCURSOR); /* XXX need a better cursor */ else WM_cursor_modal_set(win, BC_PAINTBRUSHCURSOR); - + /* only start drawing immediately if we're allowed to do so... */ if (RNA_boolean_get(op->ptr, "wait_for_input") == false) { /* hotkey invoked - start drawing */ /* printf("\tGP - set first spot\n"); */ p->status = GP_STATUS_PAINTING; - + /* handle the initial drawing - i.e. for just doing a simple dot */ gpencil_draw_apply_event(op, event); } @@ -1757,7 +1757,7 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event /* toolbar invoked - don't start drawing yet... */ /* printf("\tGP - hotkey invoked... waiting for click-drag\n"); */ } - + WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); /* add a modal handler for this operator, so that we can then draw continuous strokes */ WM_event_add_modal_handler(C, op); @@ -1774,7 +1774,7 @@ static bool gpencil_area_exists(bContext *C, ScrArea *sa_test) static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op) { tGPsdata *p = op->customdata; - + /* we must check that we're still within the area that we're set up to work from * otherwise we could crash (see bug #20586) */ @@ -1782,20 +1782,20 @@ static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op) printf("\t\t\tGP - wrong area execution abort!\n"); p->status = GP_STATUS_ERROR; } - + /* printf("\t\tGP - start stroke\n"); */ - + /* we may need to set up paint env again if we're resuming */ /* XXX: watch it with the paintmode! in future, * it'd be nice to allow changing paint-mode when in sketching-sessions */ /* XXX: with tablet events, we may event want to check for eraser here, for nicer tablet support */ - + if (gp_session_initdata(C, p)) gp_paint_initstroke(p, p->paintmode); - + if (p->status != GP_STATUS_ERROR) p->status = GP_STATUS_PAINTING; - + return op->customdata; } @@ -1821,7 +1821,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) { tGPsdata *p = op->customdata; int estate = OPERATOR_PASS_THROUGH; /* default exit state - pass through to support MMB view nav, etc. */ - + /* if (event->type == NDOF_MOTION) * return OPERATOR_PASS_THROUGH; * ------------------------------- @@ -1847,10 +1847,10 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) estate = OPERATOR_RUNNING_MODAL; } } - + //printf("\tGP - handle modal event...\n"); - - /* exit painting mode (and/or end current stroke) + + /* exit painting mode (and/or end current stroke) * NOTE: cannot do RIGHTMOUSE (as is standard for canceling) as that would break polyline [#32647] */ if (ELEM(event->type, RETKEY, PADENTER, ESCKEY, SPACEKEY)) { @@ -1859,8 +1859,8 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) p->status = GP_STATUS_DONE; estate = OPERATOR_FINISHED; } - - /* toggle painting mode upon mouse-button movement + + /* toggle painting mode upon mouse-button movement * - LEFTMOUSE = standard drawing (all) / straight line drawing (all) / polyline (toolbox only) * - RIGHTMOUSE = polyline (hotkey) / eraser (all) * (Disabling RIGHTMOUSE case here results in bugs like [#32647]) @@ -1869,22 +1869,22 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) /* if painting, end stroke */ if (p->status == GP_STATUS_PAINTING) { int sketch = 0; - - /* basically, this should be mouse-button up = end stroke + + /* basically, this should be mouse-button up = end stroke * BUT what happens next depends on whether we 'painting sessions' is enabled */ sketch |= GPENCIL_SKETCH_SESSIONS_ON(p->scene); /* polyline drawing is also 'sketching' -- all knots should be added during one session */ sketch |= (p->paintmode == GP_PAINTMODE_DRAW_POLY); - + if (sketch) { /* end stroke only, and then wait to resume painting soon */ /* printf("\t\tGP - end stroke only\n"); */ gpencil_stroke_end(op); - + /* we've just entered idling state, so this event was processed (but no others yet) */ estate = OPERATOR_RUNNING_MODAL; - + /* stroke could be smoothed, send notifier to refresh screen */ WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); } @@ -1897,7 +1897,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) else if (event->val == KM_PRESS) { /* not painting, so start stroke (this should be mouse-button down) */ p = gpencil_stroke_begin(C, op); - + if (p->status == GP_STATUS_ERROR) { estate = OPERATOR_CANCELLED; } @@ -1906,7 +1906,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) p->status = GP_STATUS_IDLING; } } - + /* handle mode-specific events */ if (p->status == GP_STATUS_PAINTING) { /* handle painting mouse-movements? */ @@ -1914,7 +1914,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) /* handle drawing event */ /* printf("\t\tGP - add point\n"); */ gpencil_draw_apply_event(op, event); - + /* finish painting operation if anything went wrong just now */ if (p->status == GP_STATUS_ERROR) { printf("\t\t\t\tGP - add error done!\n"); @@ -1939,23 +1939,23 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) case PADPLUSKEY: p->radius += 5; break; - + case WHEELUPMOUSE: /* smaller */ case PADMINUS: p->radius -= 5; - - if (p->radius < 0) + + if (p->radius < 0) p->radius = 0; break; } - + /* force refresh */ ED_region_tag_redraw(p->ar); /* just active area for now, since doing whole screen is too slow */ - + /* event handled, so just tag as running modal */ estate = OPERATOR_RUNNING_MODAL; } - /* there shouldn't be any other events, but just in case there are, let's swallow them + /* there shouldn't be any other events, but just in case there are, let's swallow them * (i.e. to prevent problems with undo) */ else { @@ -1963,14 +1963,14 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) estate = OPERATOR_RUNNING_MODAL; } } - + /* gpencil modal operator stores area, which can be removed while using it (like fullscreen) */ if (0 == gpencil_area_exists(C, p->sa)) estate = OPERATOR_CANCELLED; else /* update status indicators - cursor, header, etc. */ gpencil_draw_status_indicators(p); - + /* process last operations before exiting */ switch (estate) { case OPERATOR_FINISHED: @@ -1978,11 +1978,11 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) gpencil_draw_exit(C, op); WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); break; - + case OPERATOR_CANCELLED: gpencil_draw_exit(C, op); break; - + case OPERATOR_RUNNING_MODAL | OPERATOR_PASS_THROUGH: /* event doesn't need to be handled */ #if 0 @@ -1991,7 +1991,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) #endif break; } - + /* return status code */ return estate; } @@ -2012,21 +2012,21 @@ void GPENCIL_OT_draw(wmOperatorType *ot) ot->name = "Grease Pencil Draw"; ot->idname = "GPENCIL_OT_draw"; 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; - + /* flags */ ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING; - + /* settings for drawing */ ot->prop = RNA_def_enum(ot->srna, "mode", prop_gpencil_drawmodes, 0, "Mode", "Way to interpret mouse movements"); RNA_def_collection_runtime(ot->srna, "stroke", &RNA_OperatorStrokeElement, "Stroke", ""); - + /* NOTE: wait for input is enabled by default, so that all UI code can work properly without needing users to know about this */ RNA_def_boolean(ot->srna, "wait_for_input", true, "Wait for Input", "Wait for first click instead of painting immediately"); } |