gpencil_select.c

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2014, Blender Foundation
 * This is a new part of Blender
 */
 
#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "MEM_guardedalloc.h"
 
#include "BLI_blenlib.h"
#include "BLI_ghash.h"
#include "BLI_lasso_2d.h"
#include "BLI_math_vector.h"
#include "BLI_utildefines.h"
 
#include "DNA_gpencil_types.h"
#include "DNA_material_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_screen_types.h"
#include "DNA_space_types.h"
 
#include "BKE_context.h"
#include "BKE_gpencil.h"
#include "BKE_gpencil_curve.h"
#include "BKE_gpencil_geom.h"
#include "BKE_material.h"
#include "BKE_report.h"
 
#include "UI_interface.h"
#include "UI_resources.h"
 
#include "WM_api.h"
#include "WM_types.h"
 
#include "RNA_access.h"
#include "RNA_define.h"
 
#include "UI_view2d.h"
 
#include "ED_gpencil.h"
#include "ED_select_utils.h"
#include "ED_view3d.h"
 
#include "DEG_depsgraph.h"
#include "DEG_depsgraph_query.h"
 
#include "gpencil_intern.h"
 
/* -------------------------------------------------------------------- */
/* Convert sculpt mask mode to Select mode */
static int gpencil_select_mode_from_sculpt(eGP_Sculpt_SelectMaskFlag mode)
{
  if (mode & GP_SCULPT_MASK_SELECTMODE_POINT) {
    return GP_SELECTMODE_POINT;
  }
  if (mode & GP_SCULPT_MASK_SELECTMODE_STROKE) {
    return GP_SELECTMODE_STROKE;
  }
  if (mode & GP_SCULPT_MASK_SELECTMODE_SEGMENT) {
    return GP_SELECTMODE_SEGMENT;
  }
  return GP_SELECTMODE_POINT;
}
 
/* Convert vertex mask mode to Select mode */
static int gpencil_select_mode_from_vertex(eGP_Sculpt_SelectMaskFlag mode)
{
  if (mode & GP_VERTEX_MASK_SELECTMODE_POINT) {
    return GP_SELECTMODE_POINT;
  }
  if (mode & GP_VERTEX_MASK_SELECTMODE_STROKE) {
    return GP_SELECTMODE_STROKE;
  }
  if (mode & GP_VERTEX_MASK_SELECTMODE_SEGMENT) {
    return GP_SELECTMODE_SEGMENT;
  }
  return GP_SELECTMODE_POINT;
}
 
static bool gpencil_select_poll(bContext *C)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  ToolSettings *ts = CTX_data_tool_settings(C);
 
  if (GPENCIL_SCULPT_MODE(gpd)) {
    if (!(GPENCIL_ANY_SCULPT_MASK(ts->gpencil_selectmode_sculpt))) {
      return false;
    }
  }
 
  if (GPENCIL_VERTEX_MODE(gpd)) {
    if (!(GPENCIL_ANY_VERTEX_MASK(ts->gpencil_selectmode_vertex))) {
      return false;
    }
  }
 
  /* We just need some visible strokes,
   * and to be in edit-mode or other modes only to catch event. */
  if (GPENCIL_ANY_MODE(gpd)) {
    /* TODO: include a check for visible strokes? */
    if (gpd->layers.first) {
      return true;
    }
  }
 
  return false;
}
 
static bool gpencil_3d_point_to_screen_space(ARegion *region,
                                             const float diff_mat[4][4],
                                             const float co[3],
                                             int r_co[2])
{
  float parent_co[3];
  mul_v3_m4v3(parent_co, diff_mat, co);
  int screen_co[2];
  if (ED_view3d_project_int_global(
          region, parent_co, screen_co, V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) ==
      V3D_PROJ_RET_OK) {
    if (!ELEM(V2D_IS_CLIPPED, screen_co[0], screen_co[1])) {
      copy_v2_v2_int(r_co, screen_co);
      return true;
    }
  }
  r_co[0] = V2D_IS_CLIPPED;
  r_co[1] = V2D_IS_CLIPPED;
  return false;
}
 
/* helper to deselect all selected strokes/points */
static void deselect_all_selected(bContext *C)
{
  /* Set selection index to 0. */
  Object *ob = CTX_data_active_object(C);
  bGPdata *gpd = ob->data;
  gpd->select_last_index = 0;
 
  CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
    /* deselect stroke and its points if selected */
    if (gps->flag & GP_STROKE_SELECT) {
      bGPDspoint *pt;
      int i;
 
      /* deselect points */
      for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
        pt->flag &= ~GP_SPOINT_SELECT;
      }
 
      /* deselect stroke itself too */
      gps->flag &= ~GP_STROKE_SELECT;
      BKE_gpencil_stroke_select_index_reset(gps);
    }
 
    /* deselect curve and curve points */
    if (gps->editcurve != NULL) {
      bGPDcurve *gpc = gps->editcurve;
      for (int j = 0; j < gpc->tot_curve_points; j++) {
        bGPDcurve_point *gpc_pt = &gpc->curve_points[j];
        BezTriple *bezt = &gpc_pt->bezt;
        gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
        BEZT_DESEL_ALL(bezt);
      }
 
      gpc->flag &= ~GP_CURVE_SELECT;
    }
  }
  CTX_DATA_END;
}
 
static void select_all_curve_points(bGPdata *gpd, bGPDstroke *gps, bGPDcurve *gpc, bool deselect)
{
  for (int i = 0; i < gpc->tot_curve_points; i++) {
    bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
    BezTriple *bezt = &gpc_pt->bezt;
    if (deselect == false) {
      gpc_pt->flag |= GP_CURVE_POINT_SELECT;
      BEZT_SEL_ALL(bezt);
    }
    else {
      gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
      BEZT_DESEL_ALL(bezt);
    }
  }
 
  if (deselect == false) {
    gpc->flag |= GP_CURVE_SELECT;
    gps->flag |= GP_STROKE_SELECT;
    BKE_gpencil_stroke_select_index_set(gpd, gps);
  }
  else {
    gpc->flag &= ~GP_CURVE_SELECT;
    gps->flag &= ~GP_STROKE_SELECT;
    BKE_gpencil_stroke_select_index_reset(gps);
  }
}
 
/* -------------------------------------------------------------------- */
static bool gpencil_select_all_poll(bContext *C)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
 
  /* We just need some visible strokes,
   * and to be in edit-mode or other modes only to catch event. */
  if (GPENCIL_ANY_MODE(gpd)) {
    if (gpd->layers.first) {
      return true;
    }
  }
 
  return false;
}
 
static int gpencil_select_all_exec(bContext *C, wmOperator *op)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  int action = RNA_enum_get(op->ptr, "action");
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  if (gpd == NULL) {
    BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data");
    return OPERATOR_CANCELLED;
  }
 
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  /* For sculpt mode, if mask is disable, only allows deselect */
  if (GPENCIL_SCULPT_MODE(gpd)) {
    ToolSettings *ts = CTX_data_tool_settings(C);
    if ((!(GPENCIL_ANY_SCULPT_MASK(ts->gpencil_selectmode_sculpt))) && (action != SEL_DESELECT)) {
      return OPERATOR_CANCELLED;
    }
  }
 
  if (is_curve_edit) {
    ED_gpencil_select_curve_toggle_all(C, action);
  }
  else {
    ED_gpencil_select_toggle_all(C, action);
  }
 
  /* updates */
  DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
  /* copy on write tag is needed, or else no refresh happens */
  DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
  WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
  WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_all(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "(De)select All Strokes";
  ot->idname = "GPENCIL_OT_select_all";
  ot->description = "Change selection of all Grease Pencil strokes currently visible";
 
  /* callbacks */
  ot->exec = gpencil_select_all_exec;
  ot->poll = gpencil_select_all_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
  WM_operator_properties_select_all(ot);
}
 
/* -------------------------------------------------------------------- */
static int gpencil_select_linked_exec(bContext *C, wmOperator *op)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  if (gpd == NULL) {
    BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data");
    return OPERATOR_CANCELLED;
  }
 
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  if (is_curve_edit) {
    GP_EDITABLE_CURVES_BEGIN(gps_iter, C, gpl, gps, gpc)
    {
      if (gpc->flag & GP_CURVE_SELECT) {
        for (int i = 0; i < gpc->tot_curve_points; i++) {
          bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
          BezTriple *bezt = &gpc_pt->bezt;
          gpc_pt->flag |= GP_CURVE_POINT_SELECT;
          BEZT_SEL_ALL(bezt);
        }
      }
    }
    GP_EDITABLE_CURVES_END(gps_iter);
  }
  else {
    /* select all points in selected strokes */
    CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
      if (gps->flag & GP_STROKE_SELECT) {
        bGPDspoint *pt;
        int i;
 
        for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
          pt->flag |= GP_SPOINT_SELECT;
        }
      }
    }
    CTX_DATA_END;
  }
 
  /* updates */
  DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
  /* copy on write tag is needed, or else no refresh happens */
  DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
  WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
  WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_linked(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "Select Linked";
  ot->idname = "GPENCIL_OT_select_linked";
  ot->description = "Select all points in same strokes as already selected points";
 
  /* callbacks */
  ot->exec = gpencil_select_linked_exec;
  ot->poll = gpencil_select_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
 
/* -------------------------------------------------------------------- */
static int gpencil_select_alternate_exec(bContext *C, wmOperator *op)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  const bool unselect_ends = RNA_boolean_get(op->ptr, "unselect_ends");
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  if (gpd == NULL) {
    BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data");
    return OPERATOR_CANCELLED;
  }
 
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  bool changed = false;
  if (is_curve_edit) {
    GP_EDITABLE_CURVES_BEGIN(gps_iter, C, gpl, gps, gpc)
    {
      if ((gps->flag & GP_STROKE_SELECT) && (gps->totpoints > 1)) {
        int idx = 0;
        int start = 0;
        if (unselect_ends) {
          start = 1;
        }
 
        for (int i = start; i < gpc->tot_curve_points; i++) {
          bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
          if ((idx % 2) == 0) {
            gpc_pt->flag |= GP_SPOINT_SELECT;
            BEZT_SEL_ALL(&gpc_pt->bezt);
          }
          else {
            gpc_pt->flag &= ~GP_SPOINT_SELECT;
            BEZT_DESEL_ALL(&gpc_pt->bezt);
          }
          idx++;
        }
 
        if (unselect_ends) {
          bGPDcurve_point *gpc_pt = &gpc->curve_points[0];
          gpc_pt->flag &= ~GP_SPOINT_SELECT;
          BEZT_DESEL_ALL(&gpc_pt->bezt);
 
          gpc_pt = &gpc->curve_points[gpc->tot_curve_points - 1];
          gpc_pt->flag &= ~GP_SPOINT_SELECT;
          BEZT_DESEL_ALL(&gpc_pt->bezt);
        }
 
        BKE_gpencil_curve_sync_selection(gpd, gps);
        changed = true;
      }
    }
    GP_EDITABLE_CURVES_END(gps_iter);
  }
  else {
    /* select all points in selected strokes */
    CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
      if ((gps->flag & GP_STROKE_SELECT) && (gps->totpoints > 1)) {
        bGPDspoint *pt;
        int row = 0;
        int start = 0;
        if (unselect_ends) {
          start = 1;
        }
 
        for (int i = start; i < gps->totpoints; i++) {
          pt = &gps->points[i];
          if ((row % 2) == 0) {
            pt->flag |= GP_SPOINT_SELECT;
          }
          else {
            pt->flag &= ~GP_SPOINT_SELECT;
          }
          row++;
        }
 
        /* unselect start and end points */
        if (unselect_ends) {
          pt = &gps->points[0];
          pt->flag &= ~GP_SPOINT_SELECT;
 
          pt = &gps->points[gps->totpoints - 1];
          pt->flag &= ~GP_SPOINT_SELECT;
        }
 
        changed = true;
      }
    }
    CTX_DATA_END;
  }
 
  if (changed) {
    /* updates */
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
 
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_alternate(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "Alternated";
  ot->idname = "GPENCIL_OT_select_alternate";
  ot->description = "Select alternative points in same strokes as already selected points";
 
  /* callbacks */
  ot->exec = gpencil_select_alternate_exec;
  ot->poll = gpencil_select_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
  /* properties */
  RNA_def_boolean(ot->srna,
                  "unselect_ends",
                  false,
                  "Unselect Ends",
                  "Do not select the first and last point of the stroke");
}
 
/* -------------------------------------------------------------------- */
typedef enum eGP_SelectGrouped {
  /* Select strokes in the same layer */
  GP_SEL_SAME_LAYER = 0,
 
  /* Select strokes with the same color */
  GP_SEL_SAME_MATERIAL = 1,
 
  /* TODO: All with same prefix -
   * Useful for isolating all layers for a particular character for instance. */
  /* TODO: All with same appearance - color/opacity/volumetric/fills ? */
} eGP_SelectGrouped;
 
/* ----------------------------------- */
 
/* On each visible layer, check for selected strokes - if found, select all others */
static bool gpencil_select_same_layer(bContext *C)
{
  Scene *scene = CTX_data_scene(C);
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  bool changed = false;
  CTX_DATA_BEGIN (C, bGPDlayer *, gpl, editable_gpencil_layers) {
    bGPDframe *gpf = BKE_gpencil_layer_frame_get(gpl, CFRA, GP_GETFRAME_USE_PREV);
    bGPDstroke *gps;
    bool found = false;
 
    if (gpf == NULL) {
      continue;
    }
 
    /* Search for a selected stroke */
    for (gps = gpf->strokes.first; gps; gps = gps->next) {
      if (ED_gpencil_stroke_can_use(C, gps)) {
        if (gps->flag & GP_STROKE_SELECT) {
          found = true;
          break;
        }
      }
    }
 
    /* Select all if found */
    if (found) {
      if (is_curve_edit) {
        for (gps = gpf->strokes.first; gps; gps = gps->next) {
          if (gps->editcurve != NULL && ED_gpencil_stroke_can_use(C, gps)) {
            bGPDcurve *gpc = gps->editcurve;
            for (int i = 0; i < gpc->tot_curve_points; i++) {
              bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
              gpc_pt->flag |= GP_CURVE_POINT_SELECT;
              BEZT_SEL_ALL(&gpc_pt->bezt);
            }
            gpc->flag |= GP_CURVE_SELECT;
            gps->flag |= GP_STROKE_SELECT;
            BKE_gpencil_stroke_select_index_set(gpd, gps);
 
            changed = true;
          }
        }
      }
      else {
        for (gps = gpf->strokes.first; gps; gps = gps->next) {
          if (ED_gpencil_stroke_can_use(C, gps)) {
            bGPDspoint *pt;
            int i;
 
            for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
              pt->flag |= GP_SPOINT_SELECT;
            }
 
            gps->flag |= GP_STROKE_SELECT;
            BKE_gpencil_stroke_select_index_set(gpd, gps);
 
            changed = true;
          }
        }
      }
    }
  }
  CTX_DATA_END;
 
  return changed;
}
 
/* Select all strokes with same colors as selected ones */
static bool gpencil_select_same_material(bContext *C)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
  /* First, build set containing all the colors of selected strokes */
  GSet *selected_colors = BLI_gset_str_new("GP Selected Colors");
 
  bool changed = false;
 
  CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
    if (gps->flag & GP_STROKE_SELECT) {
      /* add instead of insert here, otherwise the uniqueness check gets skipped,
       * and we get many duplicate entries...
       */
      BLI_gset_add(selected_colors, &gps->mat_nr);
    }
  }
  CTX_DATA_END;
 
  /* Second, select any visible stroke that uses these colors */
  if (is_curve_edit) {
    CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
      if (gps->editcurve != NULL && BLI_gset_haskey(selected_colors, &gps->mat_nr)) {
        bGPDcurve *gpc = gps->editcurve;
        for (int i = 0; i < gpc->tot_curve_points; i++) {
          bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
          gpc_pt->flag |= GP_CURVE_POINT_SELECT;
          BEZT_SEL_ALL(&gpc_pt->bezt);
        }
        gpc->flag |= GP_CURVE_SELECT;
        gps->flag |= GP_STROKE_SELECT;
        BKE_gpencil_stroke_select_index_set(gpd, gps);
 
        changed = true;
      }
    }
    CTX_DATA_END;
  }
  else {
    CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
      if (BLI_gset_haskey(selected_colors, &gps->mat_nr)) {
        /* select this stroke */
        bGPDspoint *pt;
        int i;
 
        for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
          pt->flag |= GP_SPOINT_SELECT;
        }
 
        gps->flag |= GP_STROKE_SELECT;
        BKE_gpencil_stroke_select_index_set(gpd, gps);
 
        changed = true;
      }
    }
    CTX_DATA_END;
  }
 
  /* Free memory. */
  if (selected_colors != NULL) {
    BLI_gset_free(selected_colors, NULL);
  }
 
  return changed;
}
 
/* ----------------------------------- */
 
static int gpencil_select_grouped_exec(bContext *C, wmOperator *op)
{
  eGP_SelectGrouped mode = RNA_enum_get(op->ptr, "type");
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  bool changed = false;
 
  switch (mode) {
    case GP_SEL_SAME_LAYER:
      changed = gpencil_select_same_layer(C);
      break;
    case GP_SEL_SAME_MATERIAL:
      changed = gpencil_select_same_material(C);
      break;
 
    default:
      BLI_assert(!"unhandled select grouped gpencil mode");
      break;
  }
 
  if (changed) {
    /* updates */
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_grouped(wmOperatorType *ot)
{
  static const EnumPropertyItem prop_select_grouped_types[] = {
      {GP_SEL_SAME_LAYER, "LAYER", 0, "Layer", "Shared layers"},
      {GP_SEL_SAME_MATERIAL, "MATERIAL", 0, "Material", "Shared materials"},
      {0, NULL, 0, NULL, NULL},
  };
 
  /* identifiers */
  ot->name = "Select Grouped";
  ot->idname = "GPENCIL_OT_select_grouped";
  ot->description = "Select all strokes with similar characteristics";
 
  /* callbacks */
  ot->invoke = WM_menu_invoke;
  ot->exec = gpencil_select_grouped_exec;
  ot->poll = gpencil_select_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
  /* props */
  ot->prop = RNA_def_enum(
      ot->srna, "type", prop_select_grouped_types, GP_SEL_SAME_LAYER, "Type", "");
}
 
/* -------------------------------------------------------------------- */
static int gpencil_select_first_exec(bContext *C, wmOperator *op)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  const bool only_selected = RNA_boolean_get(op->ptr, "only_selected_strokes");
  const bool extend = RNA_boolean_get(op->ptr, "extend");
 
  bool changed = false;
  CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
    /* skip stroke if we're only manipulating selected strokes */
    if (only_selected && !(gps->flag & GP_STROKE_SELECT)) {
      continue;
    }
 
    /* select first point */
    BLI_assert(gps->totpoints >= 1);
 
    if (is_curve_edit) {
      if (gps->editcurve != NULL) {
        bGPDcurve *gpc = gps->editcurve;
        gpc->curve_points[0].flag |= GP_CURVE_POINT_SELECT;
        BEZT_SEL_ALL(&gpc->curve_points[0].bezt);
        gpc->flag |= GP_CURVE_SELECT;
        gps->flag |= GP_STROKE_SELECT;
        BKE_gpencil_stroke_select_index_set(gpd, gps);
 
        if ((extend == false) && (gps->totpoints > 1)) {
          for (int i = 1; i < gpc->tot_curve_points; i++) {
            bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
            gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
            BEZT_DESEL_ALL(&gpc_pt->bezt);
          }
        }
        changed = true;
      }
    }
    else {
      gps->points->flag |= GP_SPOINT_SELECT;
      gps->flag |= GP_STROKE_SELECT;
      BKE_gpencil_stroke_select_index_set(gpd, gps);
 
      /* deselect rest? */
      if ((extend == false) && (gps->totpoints > 1)) {
        /* start from index 1, to skip the first point that we'd just selected... */
        bGPDspoint *pt = &gps->points[1];
        int i = 1;
 
        for (; i < gps->totpoints; i++, pt++) {
          pt->flag &= ~GP_SPOINT_SELECT;
        }
      }
      changed = true;
    }
  }
  CTX_DATA_END;
 
  if (changed) {
    /* updates */
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
 
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_first(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "Select First";
  ot->idname = "GPENCIL_OT_select_first";
  ot->description = "Select first point in Grease Pencil strokes";
 
  /* callbacks */
  ot->exec = gpencil_select_first_exec;
  ot->poll = gpencil_select_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
  /* properties */
  RNA_def_boolean(ot->srna,
                  "only_selected_strokes",
                  false,
                  "Selected Strokes Only",
                  "Only select the first point of strokes that already have points selected");
 
  RNA_def_boolean(ot->srna,
                  "extend",
                  false,
                  "Extend",
                  "Extend selection instead of deselecting all other selected points");
}
 
/* -------------------------------------------------------------------- */
static int gpencil_select_last_exec(bContext *C, wmOperator *op)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  const bool only_selected = RNA_boolean_get(op->ptr, "only_selected_strokes");
  const bool extend = RNA_boolean_get(op->ptr, "extend");
 
  bool changed = false;
  CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
    /* skip stroke if we're only manipulating selected strokes */
    if (only_selected && !(gps->flag & GP_STROKE_SELECT)) {
      continue;
    }
 
    /* select last point */
    BLI_assert(gps->totpoints >= 1);
 
    if (is_curve_edit) {
      if (gps->editcurve != NULL) {
        bGPDcurve *gpc = gps->editcurve;
        gpc->curve_points[gpc->tot_curve_points - 1].flag |= GP_CURVE_POINT_SELECT;
        BEZT_SEL_ALL(&gpc->curve_points[gpc->tot_curve_points - 1].bezt);
        gpc->flag |= GP_CURVE_SELECT;
        gps->flag |= GP_STROKE_SELECT;
        BKE_gpencil_stroke_select_index_set(gpd, gps);
        if ((extend == false) && (gps->totpoints > 1)) {
          for (int i = 0; i < gpc->tot_curve_points - 1; i++) {
            bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
            gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
            BEZT_DESEL_ALL(&gpc_pt->bezt);
          }
        }
        changed = true;
      }
    }
    else {
      gps->points[gps->totpoints - 1].flag |= GP_SPOINT_SELECT;
      gps->flag |= GP_STROKE_SELECT;
      BKE_gpencil_stroke_select_index_set(gpd, gps);
 
      /* deselect rest? */
      if ((extend == false) && (gps->totpoints > 1)) {
        /* don't include the last point... */
        bGPDspoint *pt = gps->points;
        int i = 0;
 
        for (; i < gps->totpoints - 1; i++, pt++) {
          pt->flag &= ~GP_SPOINT_SELECT;
        }
      }
 
      changed = true;
    }
  }
  CTX_DATA_END;
 
  if (changed) {
    /* updates */
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
 
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_last(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "Select Last";
  ot->idname = "GPENCIL_OT_select_last";
  ot->description = "Select last point in Grease Pencil strokes";
 
  /* callbacks */
  ot->exec = gpencil_select_last_exec;
  ot->poll = gpencil_select_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
  /* properties */
  RNA_def_boolean(ot->srna,
                  "only_selected_strokes",
                  false,
                  "Selected Strokes Only",
                  "Only select the last point of strokes that already have points selected");
 
  RNA_def_boolean(ot->srna,
                  "extend",
                  false,
                  "Extend",
                  "Extend selection instead of deselecting all other selected points");
}
 
/* -------------------------------------------------------------------- */
static int gpencil_select_more_exec(bContext *C, wmOperator *UNUSED(op))
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  bool changed = false;
  if (is_curve_edit) {
    GP_EDITABLE_STROKES_BEGIN (gp_iter, C, gpl, gps) {
      if (gps->editcurve != NULL && gps->flag & GP_STROKE_SELECT) {
        bGPDcurve *editcurve = gps->editcurve;
 
        bool prev_sel = false;
        for (int i = 0; i < editcurve->tot_curve_points; i++) {
          bGPDcurve_point *gpc_pt = &editcurve->curve_points[i];
          BezTriple *bezt = &gpc_pt->bezt;
          if (gpc_pt->flag & GP_CURVE_POINT_SELECT) {
            /* selected point - just set flag for next point */
            prev_sel = true;
          }
          else {
            /* unselected point - expand selection if previous was selected... */
            if (prev_sel) {
              gpc_pt->flag |= GP_CURVE_POINT_SELECT;
              BEZT_SEL_ALL(bezt);
              changed = true;
            }
            prev_sel = false;
          }
        }
 
        prev_sel = false;
        for (int i = editcurve->tot_curve_points - 1; i >= 0; i--) {
          bGPDcurve_point *gpc_pt = &editcurve->curve_points[i];
          BezTriple *bezt = &gpc_pt->bezt;
          if (gpc_pt->flag & GP_CURVE_POINT_SELECT) {
            prev_sel = true;
          }
          else {
            /* unselected point - expand selection if previous was selected... */
            if (prev_sel) {
              gpc_pt->flag |= GP_CURVE_POINT_SELECT;
              BEZT_SEL_ALL(bezt);
              changed = true;
            }
            prev_sel = false;
          }
        }
      }
    }
    GP_EDITABLE_STROKES_END(gp_iter);
  }
  else {
    CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
      if (gps->flag & GP_STROKE_SELECT) {
        bGPDspoint *pt;
        int i;
        bool prev_sel;
 
        /* First Pass: Go in forward order,
         * expanding selection if previous was selected (pre changes).
         * - This pass covers the "after" edges of selection islands
         */
        prev_sel = false;
        for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
          if (pt->flag & GP_SPOINT_SELECT) {
            /* selected point - just set flag for next point */
            prev_sel = true;
          }
          else {
            /* unselected point - expand selection if previous was selected... */
            if (prev_sel) {
              pt->flag |= GP_SPOINT_SELECT;
              changed = true;
            }
            prev_sel = false;
          }
        }
 
        /* Second Pass: Go in reverse order, doing the same as before (except in opposite order)
         * - This pass covers the "before" edges of selection islands
         */
        prev_sel = false;
        for (pt -= 1; i > 0; i--, pt--) {
          if (pt->flag & GP_SPOINT_SELECT) {
            prev_sel = true;
          }
          else {
            /* unselected point - expand selection if previous was selected... */
            if (prev_sel) {
              pt->flag |= GP_SPOINT_SELECT;
              changed = true;
            }
            prev_sel = false;
          }
        }
      }
    }
    CTX_DATA_END;
  }
 
  if (changed) {
    /* updates */
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
 
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_more(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "Select More";
  ot->idname = "GPENCIL_OT_select_more";
  ot->description = "Grow sets of selected Grease Pencil points";
 
  /* callbacks */
  ot->exec = gpencil_select_more_exec;
  ot->poll = gpencil_select_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
 
/* -------------------------------------------------------------------- */
static int gpencil_select_less_exec(bContext *C, wmOperator *UNUSED(op))
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  bool changed = false;
  if (is_curve_edit) {
    GP_EDITABLE_STROKES_BEGIN (gp_iter, C, gpl, gps) {
      if (gps->editcurve != NULL && gps->flag & GP_STROKE_SELECT) {
        bGPDcurve *editcurve = gps->editcurve;
        int i;
 
        bool prev_sel = false;
        for (i = 0; i < editcurve->tot_curve_points; i++) {
          bGPDcurve_point *gpc_pt = &editcurve->curve_points[i];
          BezTriple *bezt = &gpc_pt->bezt;
          if (gpc_pt->flag & GP_CURVE_POINT_SELECT) {
            /* shrink if previous wasn't selected */
            if (prev_sel == false) {
              gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
              BEZT_DESEL_ALL(bezt);
              changed = true;
            }
            prev_sel = true;
          }
          else {
            /* mark previous as being unselected - and hence, is trigger for shrinking */
            prev_sel = false;
          }
        }
 
        /* Second Pass: Go in reverse order, doing the same as before (except in opposite order)
         * - This pass covers the "before" edges of selection islands
         */
        prev_sel = false;
        for (i = editcurve->tot_curve_points - 1; i > 0; i--) {
          bGPDcurve_point *gpc_pt = &editcurve->curve_points[i];
          BezTriple *bezt = &gpc_pt->bezt;
          if (gpc_pt->flag & GP_CURVE_POINT_SELECT) {
            /* shrink if previous wasn't selected */
            if (prev_sel == false) {
              gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
              BEZT_DESEL_ALL(bezt);
              changed = true;
            }
            prev_sel = true;
          }
          else {
            /* mark previous as being unselected - and hence, is trigger for shrinking */
            prev_sel = false;
          }
        }
      }
    }
    GP_EDITABLE_STROKES_END(gp_iter);
  }
  else {
    CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
      if (gps->flag & GP_STROKE_SELECT) {
        bGPDspoint *pt;
        int i;
        bool prev_sel;
 
        /* First Pass: Go in forward order, shrinking selection
         * if previous was not selected (pre changes).
         * - This pass covers the "after" edges of selection islands
         */
        prev_sel = false;
        for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
          if (pt->flag & GP_SPOINT_SELECT) {
            /* shrink if previous wasn't selected */
            if (prev_sel == false) {
              pt->flag &= ~GP_SPOINT_SELECT;
              changed = true;
            }
            prev_sel = true;
          }
          else {
            /* mark previous as being unselected - and hence, is trigger for shrinking */
            prev_sel = false;
          }
        }
 
        /* Second Pass: Go in reverse order, doing the same as before (except in opposite order)
         * - This pass covers the "before" edges of selection islands
         */
        prev_sel = false;
        for (pt -= 1; i > 0; i--, pt--) {
          if (pt->flag & GP_SPOINT_SELECT) {
            /* shrink if previous wasn't selected */
            if (prev_sel == false) {
              pt->flag &= ~GP_SPOINT_SELECT;
              changed = true;
            }
            prev_sel = true;
          }
          else {
            /* mark previous as being unselected - and hence, is trigger for shrinking */
            prev_sel = false;
          }
        }
      }
    }
    CTX_DATA_END;
  }
 
  if (changed) {
    /* updates */
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
 
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_less(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "Select Less";
  ot->idname = "GPENCIL_OT_select_less";
  ot->description = "Shrink sets of selected Grease Pencil points";
 
  /* callbacks */
  ot->exec = gpencil_select_less_exec;
  ot->poll = gpencil_select_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
 
/* -------------------------------------------------------------------- */
static bool gpencil_stroke_do_circle_sel(bGPdata *gpd,
                                         bGPDlayer *gpl,
                                         bGPDstroke *gps,
                                         GP_SpaceConversion *gsc,
                                         const int mx,
                                         const int my,
                                         const int radius,
                                         const bool select,
                                         rcti *rect,
                                         const float diff_mat[4][4],
                                         const int selectmode,
                                         const float scale,
                                         const bool is_curve_edit)
{
  bGPDspoint *pt = NULL;
  int x0 = 0, y0 = 0;
  int i;
  bool changed = false;
  bGPDstroke *gps_active = (gps->runtime.gps_orig) ? gps->runtime.gps_orig : gps;
  bGPDspoint *pt_active = NULL;
  bool hit = false;
 
  for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
    pt_active = (pt->runtime.pt_orig) ? pt->runtime.pt_orig : pt;
 
    bGPDspoint pt_temp;
    gpencil_point_to_parent_space(pt, diff_mat, &pt_temp);
    gpencil_point_to_xy(gsc, gps, &pt_temp, &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 */
      if (((x0 - mx) * (x0 - mx) + (y0 - my) * (y0 - my)) <= radius * radius) {
        hit = true;
 
        /* change selection */
        if (select) {
          pt_active->flag |= GP_SPOINT_SELECT;
          gps_active->flag |= GP_STROKE_SELECT;
          BKE_gpencil_stroke_select_index_set(gpd, gps_active);
        }
        else {
          pt_active->flag &= ~GP_SPOINT_SELECT;
          gps_active->flag &= ~GP_STROKE_SELECT;
          BKE_gpencil_stroke_select_index_reset(gps_active);
        }
        changed = true;
        /* if stroke mode, don't check more points */
        if ((hit) && (selectmode == GP_SELECTMODE_STROKE)) {
          break;
        }
 
        /* Expand selection to segment. */
        if ((hit) && (selectmode == GP_SELECTMODE_SEGMENT) && (select) && (pt_active != NULL)) {
          float r_hita[3], r_hitb[3];
          bool hit_select = (bool)(pt_active->flag & GP_SPOINT_SELECT);
          ED_gpencil_select_stroke_segment(
              gpd, gpl, gps_active, pt_active, hit_select, false, scale, r_hita, r_hitb);
        }
      }
    }
  }
 
  /* If stroke mode expand selection. */
  if ((hit) && (selectmode == GP_SELECTMODE_STROKE)) {
    for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
      pt_active = (pt->runtime.pt_orig) ? pt->runtime.pt_orig : pt;
      if (pt_active != NULL) {
        if (select) {
          pt_active->flag |= GP_SPOINT_SELECT;
        }
        else {
          pt_active->flag &= ~GP_SPOINT_SELECT;
        }
      }
    }
  }
 
  /* If curve edit mode, generate the curve. */
  if (is_curve_edit && hit && gps_active->editcurve == NULL) {
    BKE_gpencil_stroke_editcurve_update(gpd, gpl, gps_active);
    gps_active->flag |= GP_STROKE_NEEDS_CURVE_UPDATE;
    /* Select all curve points. */
    select_all_curve_points(gpd, gps_active, gps_active->editcurve, false);
    BKE_gpencil_stroke_geometry_update(gpd, gps_active);
    changed = true;
  }
 
  /* Ensure that stroke selection is in sync with its points. */
  BKE_gpencil_stroke_sync_selection(gpd, gps_active);
 
  return changed;
}
 
static bool gpencil_do_curve_circle_sel(bContext *C,
                                        bGPDstroke *gps,
                                        bGPDcurve *gpc,
                                        const int mx,
                                        const int my,
                                        const int radius,
                                        const bool select,
                                        rcti *rect,
                                        const float diff_mat[4][4],
                                        const int selectmode)
{
  ARegion *region = CTX_wm_region(C);
  View3D *v3d = CTX_wm_view3d(C);
  Object *ob = CTX_data_active_object(C);
  bGPdata *gpd = ob->data;
 
  const bool only_selected = (v3d->overlay.handle_display == CURVE_HANDLE_SELECTED);
 
  bool hit = false;
  for (int i = 0; i < gpc->tot_curve_points; i++) {
    bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
    BezTriple *bezt = &gpc_pt->bezt;
 
    if (bezt->hide == 1) {
      continue;
    }
 
    const bool handles_visible = (v3d->overlay.handle_display != CURVE_HANDLE_NONE) &&
                                 (!only_selected || BEZT_ISSEL_ANY(bezt));
 
    /* if the handles are not visible only check ctrl point (vec[1])*/
    int from = (!handles_visible) ? 1 : 0;
    int to = (!handles_visible) ? 2 : 3;
 
    for (int j = from; j < to; j++) {
      float parent_co[3];
      mul_v3_m4v3(parent_co, diff_mat, bezt->vec[j]);
      int screen_co[2];
      /* do 2d projection */
      if (ED_view3d_project_int_global(
              region, parent_co, screen_co, V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) !=
          V3D_PROJ_RET_OK) {
        continue;
      }
 
      /* view and bounding box test */
      if (ELEM(V2D_IS_CLIPPED, screen_co[0], screen_co[1]) &&
          !BLI_rcti_isect_pt(rect, screen_co[0], screen_co[1])) {
        continue;
      }
 
      /* test inside circle */
      int dist_x = screen_co[0] - mx;
      int dist_y = screen_co[1] - my;
      int dist = dist_x * dist_x + dist_y * dist_y;
      if (dist <= radius * radius) {
        hit = true;
        /* change selection */
        if (select) {
          gpc_pt->flag |= GP_CURVE_POINT_SELECT;
          BEZT_SEL_IDX(bezt, j);
        }
        else {
          BEZT_DESEL_IDX(bezt, j);
          if (!BEZT_ISSEL_ANY(bezt)) {
            gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
          }
        }
      }
    }
  }
 
  /* select the entire curve */
  if (hit && (selectmode == GP_SELECTMODE_STROKE)) {
    for (int i = 0; i < gpc->tot_curve_points; i++) {
      bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
      BezTriple *bezt = &gpc_pt->bezt;
 
      if (select) {
        gpc_pt->flag |= GP_CURVE_POINT_SELECT;
        BEZT_SEL_ALL(bezt);
      }
      else {
        gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
        BEZT_DESEL_ALL(bezt);
      }
    }
  }
 
  BKE_gpencil_curve_sync_selection(gpd, gps);
 
  return hit;
}
 
static int gpencil_circle_select_exec(bContext *C, wmOperator *op)
{
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  ToolSettings *ts = CTX_data_tool_settings(C);
  Object *ob = CTX_data_active_object(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  int selectmode;
  if (ob && ob->mode == OB_MODE_SCULPT_GPENCIL) {
    selectmode = gpencil_select_mode_from_sculpt(ts->gpencil_selectmode_sculpt);
  }
  else if (ob && ob->mode == OB_MODE_VERTEX_GPENCIL) {
    selectmode = gpencil_select_mode_from_vertex(ts->gpencil_selectmode_vertex);
  }
  else {
    selectmode = ts->gpencil_selectmode_edit;
  }
 
  const float scale = ts->gp_sculpt.isect_threshold;
 
  /* If not edit/sculpt mode, the event has been caught but not processed. */
  if (GPENCIL_NONE_EDIT_MODE(gpd)) {
    return OPERATOR_CANCELLED;
  }
 
  ScrArea *area = CTX_wm_area(C);
 
  const int mx = RNA_int_get(op->ptr, "x");
  const int my = RNA_int_get(op->ptr, "y");
  const int radius = RNA_int_get(op->ptr, "radius");
 
  /* sanity checks */
  if (area == NULL) {
    BKE_report(op->reports, RPT_ERROR, "No active area");
    return OPERATOR_CANCELLED;
  }
 
  const eSelectOp sel_op = ED_select_op_modal(RNA_enum_get(op->ptr, "mode"),
                                              WM_gesture_is_modal_first(op->customdata));
  const bool select = (sel_op != SEL_OP_SUB);
 
  bool changed = false;
  /* for bounding rect around circle (for quicky intersection testing) */
  rcti rect = {0};
  rect.xmin = mx - radius;
  rect.ymin = my - radius;
  rect.xmax = mx + radius;
  rect.ymax = my + radius;
 
  if (is_curve_edit) {
    if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
      ED_gpencil_select_curve_toggle_all(C, SEL_DESELECT);
      changed = true;
    }
 
    GP_EDITABLE_CURVES_BEGIN(gps_iter, C, gpl, gps, gpc)
    {
      changed |= gpencil_do_curve_circle_sel(
          C, gps, gpc, mx, my, radius, select, &rect, gps_iter.diff_mat, selectmode);
    }
    GP_EDITABLE_CURVES_END(gps_iter);
  }
 
  if (changed == false) {
    GP_SpaceConversion gsc = {NULL};
    /* init space conversion stuff */
    gpencil_point_conversion_init(C, &gsc);
 
    if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
      ED_gpencil_select_toggle_all(C, SEL_DESELECT);
      changed = true;
    }
 
    /* find visible strokes, and select if hit */
    GP_EVALUATED_STROKES_BEGIN (gpstroke_iter, C, gpl, gps) {
      changed |= gpencil_stroke_do_circle_sel(gpd,
                                              gpl,
                                              gps,
                                              &gsc,
                                              mx,
                                              my,
                                              radius,
                                              select,
                                              &rect,
                                              gpstroke_iter.diff_mat,
                                              selectmode,
                                              scale,
                                              is_curve_edit);
    }
    GP_EVALUATED_STROKES_END(gpstroke_iter);
  }
 
  /* updates */
  if (changed) {
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
 
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_circle(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "Circle Select";
  ot->description = "Select Grease Pencil strokes using brush selection";
  ot->idname = "GPENCIL_OT_select_circle";
 
  /* callbacks */
  ot->invoke = WM_gesture_circle_invoke;
  ot->modal = WM_gesture_circle_modal;
  ot->exec = gpencil_circle_select_exec;
  ot->poll = gpencil_select_poll;
  ot->cancel = WM_gesture_circle_cancel;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
  /* properties */
  WM_operator_properties_gesture_circle(ot);
  WM_operator_properties_select_operation_simple(ot);
}
 
/* -------------------------------------------------------------------- */
typedef struct GP_SelectUserData {
  int mx, my, radius;
  /* Bounding box rect */
  rcti rect;
  const int (*lasso_coords)[2];
  int lasso_coords_len;
} GP_SelectUserData;
 
typedef bool (*GPencilTestFn)(ARegion *region,
                              const float diff_mat[4][4],
                              const float pt[3],
                              GP_SelectUserData *user_data);
 
#if 0
static bool gpencil_stroke_fill_isect_rect(ARegion *region,
                                           bGPDstroke *gps,
                                           const float diff_mat[4][4],
                                           rcti rect)
{
  int min[2] = {-INT_MAX, -INT_MAX};
  int max[2] = {INT_MAX, INT_MAX};
 
  int(*points2d)[2] = MEM_callocN(sizeof(int[2]) * gps->totpoints, __func__);
 
  for (int i = 0; i < gps->totpoints; i++) {
    bGPDspoint *pt = &gps->points[i];
    int *pt2d = points2d[i];
 
    int screen_co[2];
    gpencil_3d_point_to_screen_space(region, diff_mat, &pt->x, screen_co);
    DO_MINMAX2(screen_co, min, max);
 
    copy_v2_v2_int(pt2d, screen_co);
  }
 
  bool hit = false;
  /* check bounding box */
  rcti bb = {min[0], max[0], min[1], max[1]};
  if (BLI_rcti_isect(&rect, &bb, NULL)) {
    for (int i = 0; i < gps->tot_triangles; i++) {
      bGPDtriangle *tri = &gps->triangles[i];
      int pt1[2], pt2[2], pt3[2];
      int tri_min[2] = {-INT_MAX, -INT_MAX};
      int tri_max[2] = {INT_MAX, INT_MAX};
 
      copy_v2_v2_int(pt1, points2d[tri->verts[0]]);
      copy_v2_v2_int(pt2, points2d[tri->verts[1]]);
      copy_v2_v2_int(pt3, points2d[tri->verts[2]]);
 
      DO_MINMAX2(pt1, tri_min, tri_max);
      DO_MINMAX2(pt2, tri_min, tri_max);
      DO_MINMAX2(pt3, tri_min, tri_max);
 
      rcti tri_bb = {tri_min[0], tri_max[0], tri_min[1], tri_max[1]};
      /* Case 1: triangle is entirely inside box selection */
      /* (XXX: Can this even happen with no point inside the box?) */
      if (BLI_rcti_inside_rcti(&tri_bb, &rect)) {
        hit = true;
        break;
      }
 
      /* Case 2: rectangle intersects sides of triangle */
      if (BLI_rcti_isect_segment(&rect, pt1, pt2) || BLI_rcti_isect_segment(&rect, pt2, pt3) ||
          BLI_rcti_isect_segment(&rect, pt3, pt1)) {
        hit = true;
        break;
      }
 
      /* TODO: Case 3: rectangle is inside the triangle */
    }
  }
 
  MEM_freeN(points2d);
  return hit;
}
#endif
 
static bool gpencil_generic_curve_select(bContext *C,
                                         Object *ob,
                                         GPencilTestFn is_inside_fn,
                                         rcti UNUSED(box),
                                         GP_SelectUserData *user_data,
                                         const bool strokemode,
                                         const eSelectOp sel_op)
{
  ARegion *region = CTX_wm_region(C);
  View3D *v3d = CTX_wm_view3d(C);
  bGPdata *gpd = ob->data;
  const bool handle_only_selected = (v3d->overlay.handle_display == CURVE_HANDLE_SELECTED);
  const bool handle_all = (v3d->overlay.handle_display == CURVE_HANDLE_ALL);
 
  bool hit = false;
  bool changed = false;
  bool whole = false;
 
  GP_EDITABLE_CURVES_BEGIN(gps_iter, C, gpl, gps, gpc)
  {
    bool any_select = false;
    for (int i = 0; i < gpc->tot_curve_points; i++) {
      bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
      BezTriple *bezt = &gpc_pt->bezt;
 
      if (bezt->hide == 1) {
        continue;
      }
 
      const bool handles_visible = (handle_all || (handle_only_selected &&
                                                   (gpc_pt->flag & GP_CURVE_POINT_SELECT)));
 
      if (handles_visible) {
        for (int j = 0; j < 3; j++) {
          const bool is_select = BEZT_ISSEL_IDX(bezt, j);
          bool is_inside = is_inside_fn(region, gps_iter.diff_mat, bezt->vec[j], user_data);
          if (strokemode) {
            if (is_inside) {
              hit = true;
              any_select = true;
              break;
            }
          }
          else {
            const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
            if (sel_op_result != -1) {
              if (sel_op_result) {
                gpc_pt->flag |= GP_CURVE_POINT_SELECT;
                BEZT_SEL_IDX(bezt, j);
                any_select = true;
              }
              else {
                gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
                BEZT_DESEL_IDX(bezt, j);
              }
              changed = true;
              hit = true;
            }
            else {
              if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
                gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
                BEZT_DESEL_IDX(bezt, j);
              }
            }
          }
        }
      }
      /* if the handles are not visible only check ctrl point (vec[1])*/
      else {
        const bool is_select = bezt->f2;
        bool is_inside = is_inside_fn(region, gps_iter.diff_mat, bezt->vec[1], user_data);
        if (strokemode) {
          if (is_inside) {
            hit = true;
            any_select = true;
          }
        }
        else {
          const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
          if (sel_op_result != -1) {
            if (sel_op_result) {
              gpc_pt->flag |= GP_CURVE_POINT_SELECT;
              bezt->f2 |= SELECT;
              any_select = true;
            }
            else {
              gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
              bezt->f2 &= ~SELECT;
            }
            changed = true;
            hit = true;
          }
          else {
            if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
              gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
              bezt->f2 &= ~SELECT;
            }
          }
        }
      }
    }
 
    /* TODO: Fix selection for filled in curves. */
#if 0
    if (!hit) {
      /* check if we selected the inside of a filled curve */
      MaterialGPencilStyle *gp_style = BKE_gpencil_material_settings(ob, gps->mat_nr + 1);
      if ((gp_style->flag & GP_MATERIAL_FILL_SHOW) == 0) {
        continue;
      }
 
      whole = gpencil_stroke_fill_isect_rect(region, gps, gps_iter.diff_mat, box);
    }
#endif
    /* select the entire curve */
    if (strokemode || whole) {
      const int sel_op_result = ED_select_op_action_deselected(sel_op, any_select, hit || whole);
      if (sel_op_result != -1) {
        for (int i = 0; i < gpc->tot_curve_points; i++) {
          bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
          BezTriple *bezt = &gpc_pt->bezt;
 
          if (sel_op_result) {
            gpc_pt->flag |= GP_CURVE_POINT_SELECT;
            BEZT_SEL_ALL(bezt);
          }
          else {
            gpc_pt->flag &= ~GP_CURVE_POINT_SELECT;
            BEZT_DESEL_ALL(bezt);
          }
        }
 
        if (sel_op_result) {
          gpc->flag |= GP_CURVE_SELECT;
        }
        else {
          gpc->flag &= ~GP_CURVE_SELECT;
        }
        changed = true;
      }
    }
 
    BKE_gpencil_curve_sync_selection(gpd, gps);
  }
  GP_EDITABLE_CURVES_END(gps_iter);
 
  return changed;
}
 
static bool gpencil_generic_stroke_select(bContext *C,
                                          Object *ob,
                                          bGPdata *gpd,
                                          GPencilTestFn is_inside_fn,
                                          rcti box,
                                          GP_SelectUserData *user_data,
                                          const bool strokemode,
                                          const bool segmentmode,
                                          const eSelectOp sel_op,
                                          const float scale,
                                          const bool is_curve_edit)
{
  GP_SpaceConversion gsc = {NULL};
  bool changed = false;
  /* init space conversion stuff */
  gpencil_point_conversion_init(C, &gsc);
 
  /* deselect all strokes first? */
  if (SEL_OP_USE_PRE_DESELECT(sel_op) || (GPENCIL_PAINT_MODE(gpd))) {
    /* Set selection index to 0. */
    gpd->select_last_index = 0;
 
    CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
      bGPDspoint *pt;
      int i;
 
      for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
        pt->flag &= ~GP_SPOINT_SELECT;
      }
 
      gps->flag &= ~GP_STROKE_SELECT;
      BKE_gpencil_stroke_select_index_reset(gps);
    }
    CTX_DATA_END;
 
    changed = true;
  }
 
  /* select/deselect points */
  GP_EVALUATED_STROKES_BEGIN (gpstroke_iter, C, gpl, gps) {
    bGPDstroke *gps_active = (gps->runtime.gps_orig) ? gps->runtime.gps_orig : gps;
    bool whole = false;
 
    bGPDspoint *pt;
    int i;
    bool hit = false;
    for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
      bGPDspoint *pt_active = (pt->runtime.pt_orig) ? pt->runtime.pt_orig : pt;
 
      /* convert point coords to screenspace */
      const bool is_inside = is_inside_fn(gsc.region, gpstroke_iter.diff_mat, &pt->x, user_data);
      if (strokemode == false) {
        const bool is_select = (pt_active->flag & GP_SPOINT_SELECT) != 0;
        const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
        if (sel_op_result != -1) {
          SET_FLAG_FROM_TEST(pt_active->flag, sel_op_result, GP_SPOINT_SELECT);
          changed = true;
          hit = true;
 
          /* Expand selection to segment. */
          if (segmentmode) {
            bool hit_select = (bool)(pt_active->flag & GP_SPOINT_SELECT);
            float r_hita[3], r_hitb[3];
            ED_gpencil_select_stroke_segment(
                gpd, gpl, gps_active, pt_active, hit_select, false, scale, r_hita, r_hitb);
          }
        }
      }
      else {
        if (is_inside) {
          hit = true;
          break;
        }
      }
    }
 
    /* If nothing hit, check if the mouse is inside a filled stroke using the center or
     * Box or lasso area. */
    if (!hit) {
      /* Only check filled strokes. */
      MaterialGPencilStyle *gp_style = BKE_gpencil_material_settings(ob, gps->mat_nr + 1);
      if ((gp_style->flag & GP_MATERIAL_FILL_SHOW) == 0) {
        continue;
      }
      int mval[2];
      mval[0] = (box.xmax + box.xmin) / 2;
      mval[1] = (box.ymax + box.ymin) / 2;
 
      whole = ED_gpencil_stroke_point_is_inside(gps, &gsc, mval, gpstroke_iter.diff_mat);
    }
 
    /* if stroke mode expand selection. */
    if ((strokemode) || (whole)) {
      const bool is_select = BKE_gpencil_stroke_select_check(gps_active) || whole;
      const bool is_inside = hit || whole;
      const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
      if (sel_op_result != -1) {
        for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
          bGPDspoint *pt_active = (pt->runtime.pt_orig) ? pt->runtime.pt_orig : pt;
 
          if (sel_op_result) {
            pt_active->flag |= GP_SPOINT_SELECT;
          }
          else {
            pt_active->flag &= ~GP_SPOINT_SELECT;
          }
        }
        changed = true;
      }
    }
 
    /* If curve edit mode, generate the curve. */
    if (is_curve_edit && (hit || whole) && gps_active->editcurve == NULL) {
      BKE_gpencil_stroke_editcurve_update(gpd, gpl, gps_active);
      gps_active->flag |= GP_STROKE_NEEDS_CURVE_UPDATE;
      /* Select all curve points. */
      select_all_curve_points(gpd, gps_active, gps_active->editcurve, false);
      BKE_gpencil_stroke_geometry_update(gpd, gps_active);
      changed = true;
    }
 
    /* Ensure that stroke selection is in sync with its points */
    BKE_gpencil_stroke_sync_selection(gpd, gps_active);
  }
  GP_EVALUATED_STROKES_END(gpstroke_iter);
 
  return changed;
}
 
static int gpencil_generic_select_exec(bContext *C,
                                       wmOperator *op,
                                       GPencilTestFn is_inside_fn,
                                       rcti box,
                                       GP_SelectUserData *user_data)
{
  Object *ob = CTX_data_active_object(C);
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  ToolSettings *ts = CTX_data_tool_settings(C);
  ScrArea *area = CTX_wm_area(C);
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  int selectmode;
  if (ob && ob->mode == OB_MODE_SCULPT_GPENCIL) {
    selectmode = gpencil_select_mode_from_sculpt(ts->gpencil_selectmode_sculpt);
  }
  else if (ob && ob->mode == OB_MODE_VERTEX_GPENCIL) {
    selectmode = gpencil_select_mode_from_vertex(ts->gpencil_selectmode_vertex);
  }
  else {
    selectmode = ts->gpencil_selectmode_edit;
  }
 
  const bool strokemode = ((selectmode == GP_SELECTMODE_STROKE) &&
                           ((gpd->flag & GP_DATA_STROKE_PAINTMODE) == 0));
  const bool segmentmode = ((selectmode == GP_SELECTMODE_SEGMENT) &&
                            ((gpd->flag & GP_DATA_STROKE_PAINTMODE) == 0));
 
  const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
  const float scale = ts->gp_sculpt.isect_threshold;
 
  bool changed = false;
 
  /* sanity checks */
  if (area == NULL) {
    BKE_report(op->reports, RPT_ERROR, "No active area");
    return OPERATOR_CANCELLED;
  }
 
  if (is_curve_edit) {
    changed = gpencil_generic_curve_select(
        C, ob, is_inside_fn, box, user_data, strokemode, sel_op);
  }
 
  if (changed == false) {
    changed = gpencil_generic_stroke_select(C,
                                            ob,
                                            gpd,
                                            is_inside_fn,
                                            box,
                                            user_data,
                                            strokemode,
                                            segmentmode,
                                            sel_op,
                                            scale,
                                            is_curve_edit);
  }
 
  /* if paint mode,delete selected points */
  if (GPENCIL_PAINT_MODE(gpd)) {
    gpencil_delete_selected_point_wrap(C);
    changed = true;
    DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
  }
 
  /* updates */
  if (changed) {
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
  return OPERATOR_FINISHED;
}
 
/* -------------------------------------------------------------------- */
static bool gpencil_test_box(ARegion *region,
                             const float diff_mat[4][4],
                             const float pt[3],
                             GP_SelectUserData *user_data)
{
  int co[2] = {0};
  if (gpencil_3d_point_to_screen_space(region, diff_mat, pt, co)) {
    return BLI_rcti_isect_pt(&user_data->rect, co[0], co[1]);
  }
  return false;
}
 
static int gpencil_box_select_exec(bContext *C, wmOperator *op)
{
  GP_SelectUserData data = {0};
  WM_operator_properties_border_to_rcti(op, &data.rect);
  rcti rect = data.rect;
  return gpencil_generic_select_exec(C, op, gpencil_test_box, rect, &data);
}
 
void GPENCIL_OT_select_box(wmOperatorType *ot)
{
  /* identifiers */
  ot->name = "Box Select";
  ot->description = "Select Grease Pencil strokes within a rectangular region";
  ot->idname = "GPENCIL_OT_select_box";
 
  /* callbacks */
  ot->invoke = WM_gesture_box_invoke;
  ot->exec = gpencil_box_select_exec;
  ot->modal = WM_gesture_box_modal;
  ot->cancel = WM_gesture_box_cancel;
 
  ot->poll = gpencil_select_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
  /* properties */
  WM_operator_properties_gesture_box(ot);
  WM_operator_properties_select_operation(ot);
}
 
/* -------------------------------------------------------------------- */
static bool gpencil_test_lasso(ARegion *region,
                               const float diff_mat[4][4],
                               const float pt[3],
                               GP_SelectUserData *user_data)
{
  int co[2] = {0};
  if (gpencil_3d_point_to_screen_space(region, diff_mat, pt, co)) {
    /* test if in lasso boundbox + within the lasso noose */
    return (BLI_rcti_isect_pt(&user_data->rect, co[0], co[1]) &&
            BLI_lasso_is_point_inside(
                user_data->lasso_coords, user_data->lasso_coords_len, co[0], co[1], INT_MAX));
  }
  return false;
}
 
static int gpencil_lasso_select_exec(bContext *C, wmOperator *op)
{
  struct GP_SelectUserData data = {0};
  data.lasso_coords = WM_gesture_lasso_path_to_array(C, op, &data.lasso_coords_len);
 
  /* Sanity check. */
  if (data.lasso_coords == NULL) {
    return OPERATOR_PASS_THROUGH;
  }
 
  /* Compute boundbox of lasso (for faster testing later). */
  BLI_lasso_boundbox(&data.rect, data.lasso_coords, data.lasso_coords_len);
 
  rcti rect = data.rect;
  int ret = gpencil_generic_select_exec(C, op, gpencil_test_lasso, rect, &data);
 
  MEM_freeN((void *)data.lasso_coords);
 
  return ret;
}
 
void GPENCIL_OT_select_lasso(wmOperatorType *ot)
{
  ot->name = "Lasso Select Strokes";
  ot->description = "Select Grease Pencil strokes using lasso selection";
  ot->idname = "GPENCIL_OT_select_lasso";
 
  ot->invoke = WM_gesture_lasso_invoke;
  ot->modal = WM_gesture_lasso_modal;
  ot->exec = gpencil_lasso_select_exec;
  ot->poll = gpencil_select_poll;
  ot->cancel = WM_gesture_lasso_cancel;
 
  /* flags */
  ot->flag = OPTYPE_UNDO;
 
  /* properties */
  WM_operator_properties_select_operation(ot);
  WM_operator_properties_gesture_lasso(ot);
}
 
/* -------------------------------------------------------------------- */
static void gpencil_select_curve_point(bContext *C,
                                       const int mval[2],
                                       const int radius_squared,
                                       bGPDlayer **r_gpl,
                                       bGPDstroke **r_gps,
                                       bGPDcurve **r_gpc,
                                       bGPDcurve_point **r_pt,
                                       char *handle)
{
  ARegion *region = CTX_wm_region(C);
  View3D *v3d = CTX_wm_view3d(C);
  const bool only_selected = (v3d->overlay.handle_display == CURVE_HANDLE_SELECTED);
 
  int hit_distance = radius_squared;
 
  GP_EDITABLE_CURVES_BEGIN(gps_iter, C, gpl, gps, gpc)
  {
    for (int i = 0; i < gpc->tot_curve_points; i++) {
      bGPDcurve_point *gpc_pt = &gpc->curve_points[i];
      BezTriple *bezt = &gpc_pt->bezt;
 
      if (bezt->hide == 1) {
        continue;
      }
 
      const bool handles_visible = (v3d->overlay.handle_display != CURVE_HANDLE_NONE) &&
                                   (!only_selected || BEZT_ISSEL_ANY(bezt));
 
      /* if the handles are not visible only check ctrl point (vec[1])*/
      int from = (!handles_visible) ? 1 : 0;
      int to = (!handles_visible) ? 2 : 3;
 
      for (int j = from; j < to; j++) {
        int screen_co[2];
        if (gpencil_3d_point_to_screen_space(region, gps_iter.diff_mat, bezt->vec[j], screen_co)) {
          const int pt_distance = len_manhattan_v2v2_int(mval, screen_co);
 
          if (pt_distance <= radius_squared && pt_distance < hit_distance) {
            *r_gpl = gpl;
            *r_gps = gps;
            *r_gpc = gpc;
            *r_pt = gpc_pt;
            *handle = j;
            hit_distance = pt_distance;
          }
        }
      }
    }
  }
  GP_EDITABLE_CURVES_END(gps_iter);
}
 
static int gpencil_select_exec(bContext *C, wmOperator *op)
{
  ScrArea *area = CTX_wm_area(C);
  Object *ob = CTX_data_active_object(C);
  bGPdata *gpd = ED_gpencil_data_get_active(C);
  ToolSettings *ts = CTX_data_tool_settings(C);
  const float scale = ts->gp_sculpt.isect_threshold;
  const bool is_curve_edit = (bool)GPENCIL_CURVE_EDIT_SESSIONS_ON(gpd);
 
  /* "radius" is simply a threshold (screen space) to make it easier to test with a tolerance */
  const float radius = 0.4f * U.widget_unit;
  const int radius_squared = (int)(radius * radius);
 
  const bool use_shift_extend = RNA_boolean_get(op->ptr, "use_shift_extend");
  bool extend = RNA_boolean_get(op->ptr, "extend") || use_shift_extend;
  bool deselect = RNA_boolean_get(op->ptr, "deselect");
  bool toggle = RNA_boolean_get(op->ptr, "toggle");
  bool whole = RNA_boolean_get(op->ptr, "entire_strokes");
  const bool deselect_all = RNA_boolean_get(op->ptr, "deselect_all") && !use_shift_extend;
 
  int mval[2] = {0};
  /* get mouse location */
  RNA_int_get_array(op->ptr, "location", mval);
 
  GP_SpaceConversion gsc = {NULL};
 
  bGPDlayer *hit_layer = NULL;
  bGPDstroke *hit_stroke = NULL;
  bGPDspoint *hit_point = NULL;
  bGPDcurve *hit_curve = NULL;
  bGPDcurve_point *hit_curve_point = NULL;
  char hit_curve_handle = 0;
  int hit_distance = radius_squared;
 
  /* sanity checks */
  if (area == NULL) {
    BKE_report(op->reports, RPT_ERROR, "No active area");
    return OPERATOR_CANCELLED;
  }
 
  /* if select mode is stroke, use whole stroke */
  if ((ob) && (ob->mode == OB_MODE_SCULPT_GPENCIL)) {
    whole |= (bool)(gpencil_select_mode_from_sculpt(ts->gpencil_selectmode_sculpt) ==
                   GP_SELECTMODE_STROKE);
  }
  else if ((ob) && (ob->mode == OB_MODE_VERTEX_GPENCIL)) {
    whole |= (bool)(gpencil_select_mode_from_vertex(ts->gpencil_selectmode_sculpt) ==
                   GP_SELECTMODE_STROKE);
  }
  else {
    whole |= (bool)(ts->gpencil_selectmode_edit == GP_SELECTMODE_STROKE);
  }
 
  if (is_curve_edit) {
    gpencil_select_curve_point(C,
                               mval,
                               radius_squared,
                               &hit_layer,
                               &hit_stroke,
                               &hit_curve,
                               &hit_curve_point,
                               &hit_curve_handle);
  }
 
  if (hit_curve == NULL) {
    /* init space conversion stuff */
    gpencil_point_conversion_init(C, &gsc);
 
    /* First Pass: Find stroke point which gets hit */
    GP_EVALUATED_STROKES_BEGIN (gpstroke_iter, C, gpl, gps) {
      bGPDstroke *gps_active = (gps->runtime.gps_orig) ? gps->runtime.gps_orig : gps;
      bGPDspoint *pt;
      int i;
 
      /* firstly, check for hit-point */
      for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
        int xy[2];
 
        bGPDspoint pt2;
        gpencil_point_to_parent_space(pt, gpstroke_iter.diff_mat, &pt2);
        gpencil_point_to_xy(&gsc, gps_active, &pt2, &xy[0], &xy[1]);
 
        /* do boundbox check first */
        if (!ELEM(V2D_IS_CLIPPED, xy[0], xy[1])) {
          const int pt_distance = len_manhattan_v2v2_int(mval, xy);
 
          /* check if point is inside */
          if (pt_distance <= radius_squared) {
            /* only use this point if it is a better match than the current hit - T44685 */
            if (pt_distance < hit_distance) {
              hit_layer = gpl;
              hit_stroke = gps_active;
              hit_point = (pt->runtime.pt_orig) ? pt->runtime.pt_orig : pt;
              hit_distance = pt_distance;
            }
          }
        }
      }
    }
    GP_EVALUATED_STROKES_END(gpstroke_iter);
  }
 
  /* Abort if nothing hit... */
  if (!hit_curve && !hit_curve_point && !hit_point && !hit_stroke) {
 
    if (deselect_all) {
      /* since left mouse select change, deselect all if click outside any hit */
      deselect_all_selected(C);
 
      /* copy on write tag is needed, or else no refresh happens */
      DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
      DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
      WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
      WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
 
      return OPERATOR_FINISHED;
    }
 
    return OPERATOR_CANCELLED;
  }
 
  /* select all handles if the click was on the curve but not on a handle */
  if (is_curve_edit && hit_point != NULL) {
    whole = true;
    hit_curve = hit_stroke->editcurve;
  }
 
  /* adjust selection behavior - for toggle option */
  if (toggle) {
    if (hit_curve_point != NULL) {
      BezTriple *bezt = &hit_curve_point->bezt;
      if ((bezt->f1 & SELECT) && (hit_curve_handle == 0)) {
        deselect = true;
      }
      if ((bezt->f2 & SELECT) && (hit_curve_handle == 1)) {
        deselect = true;
      }
      if ((bezt->f3 & SELECT) && (hit_curve_handle == 2)) {
        deselect = true;
      }
    }
    else {
      deselect = (hit_point->flag & GP_SPOINT_SELECT) != 0;
    }
  }
 
  /* If not extending selection, deselect everything else */
  if (extend == false) {
    deselect_all_selected(C);
  }
 
  /* Perform selection operations... */
  if (whole) {
    /* Generate editcurve if it does not exist */
    if (is_curve_edit && hit_curve == NULL) {
      BKE_gpencil_stroke_editcurve_update(gpd, hit_layer, hit_stroke);
      hit_stroke->flag |= GP_STROKE_NEEDS_CURVE_UPDATE;
      BKE_gpencil_stroke_geometry_update(gpd, hit_stroke);
      hit_curve = hit_stroke->editcurve;
    }
    /* select all curve points */
    if (hit_curve != NULL) {
      select_all_curve_points(gpd, hit_stroke, hit_curve, deselect);
    }
    else {
      bGPDspoint *pt;
      int i;
 
      /* entire stroke's points */
      for (i = 0, pt = hit_stroke->points; i < hit_stroke->totpoints; i++, pt++) {
        if (deselect == false) {
          pt->flag |= GP_SPOINT_SELECT;
        }
        else {
          pt->flag &= ~GP_SPOINT_SELECT;
        }
      }
 
      /* stroke too... */
      if (deselect == false) {
        hit_stroke->flag |= GP_STROKE_SELECT;
        BKE_gpencil_stroke_select_index_set(gpd, hit_stroke);
      }
      else {
        hit_stroke->flag &= ~GP_STROKE_SELECT;
        BKE_gpencil_stroke_select_index_reset(hit_stroke);
      }
    }
  }
  else {
    /* just the point (and the stroke) */
    if (deselect == false) {
      if (hit_curve_point != NULL) {
        hit_curve_point->flag |= GP_CURVE_POINT_SELECT;
        BEZT_SEL_IDX(&hit_curve_point->bezt, hit_curve_handle);
        hit_curve->flag |= GP_CURVE_SELECT;
        hit_stroke->flag |= GP_STROKE_SELECT;
        BKE_gpencil_stroke_select_index_set(gpd, hit_stroke);
      }
      else {
        /* we're adding selection, so selection must be true */
        hit_point->flag |= GP_SPOINT_SELECT;
        hit_stroke->flag |= GP_STROKE_SELECT;
        BKE_gpencil_stroke_select_index_set(gpd, hit_stroke);
 
        /* expand selection to segment */
        int selectmode;
        if (ob && ob->mode == OB_MODE_SCULPT_GPENCIL) {
          selectmode = gpencil_select_mode_from_sculpt(ts->gpencil_selectmode_sculpt);
        }
        else if (ob && ob->mode == OB_MODE_VERTEX_GPENCIL) {
          selectmode = gpencil_select_mode_from_vertex(ts->gpencil_selectmode_vertex);
        }
        else {
          selectmode = ts->gpencil_selectmode_edit;
        }
 
        if (selectmode == GP_SELECTMODE_SEGMENT) {
          float r_hita[3], r_hitb[3];
          bool hit_select = (bool)(hit_point->flag & GP_SPOINT_SELECT);
          ED_gpencil_select_stroke_segment(
              gpd, hit_layer, hit_stroke, hit_point, hit_select, false, scale, r_hita, r_hitb);
        }
      }
    }
    else {
      if (hit_curve_point != NULL) {
        BEZT_DESEL_IDX(&hit_curve_point->bezt, hit_curve_handle);
        if (!BEZT_ISSEL_ANY(&hit_curve_point->bezt)) {
          hit_curve_point->flag &= ~GP_CURVE_POINT_SELECT;
        }
        BKE_gpencil_curve_sync_selection(gpd, hit_stroke);
      }
      else {
        /* deselect point */
        hit_point->flag &= ~GP_SPOINT_SELECT;
 
        /* ensure that stroke is selected correctly */
        BKE_gpencil_stroke_sync_selection(gpd, hit_stroke);
      }
    }
  }
 
  /* updates */
  if (hit_curve_point != NULL || hit_point != NULL) {
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
 
  return OPERATOR_FINISHED;
}
 
static int gpencil_select_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
  RNA_int_set_array(op->ptr, "location", event->mval);
 
  if (!RNA_struct_property_is_set(op->ptr, "use_shift_extend")) {
    RNA_boolean_set(op->ptr, "use_shift_extend", event->shift);
  }
 
  return gpencil_select_exec(C, op);
}
 
void GPENCIL_OT_select(wmOperatorType *ot)
{
  PropertyRNA *prop;
 
  /* identifiers */
  ot->name = "Select";
  ot->description = "Select Grease Pencil strokes and/or stroke points";
  ot->idname = "GPENCIL_OT_select";
 
  /* callbacks */
  ot->invoke = gpencil_select_invoke;
  ot->exec = gpencil_select_exec;
  ot->poll = gpencil_select_poll;
 
  /* flag */
  ot->flag = OPTYPE_UNDO;
 
  /* properties */
  WM_operator_properties_mouse_select(ot);
 
  prop = RNA_def_boolean(ot->srna,
                         "entire_strokes",
                         false,
                         "Entire Strokes",
                         "Select entire strokes instead of just the nearest stroke vertex");
  RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 
  prop = RNA_def_int_vector(ot->srna,
                            "location",
                            2,
                            NULL,
                            INT_MIN,
                            INT_MAX,
                            "Location",
                            "Mouse location",
                            INT_MIN,
                            INT_MAX);
  RNA_def_property_flag(prop, PROP_HIDDEN);
 
  prop = RNA_def_boolean(ot->srna, "use_shift_extend", false, "Extend", "");
  RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
}
 
/* Select by Vertex Color. */
/* Helper to create a hash of colors. */
static void gpencil_selected_hue_table(bContext *C,
                                       Object *ob,
                                       const int threshold,
                                       GHash *hue_table)
{
  const float range = pow(10, 5 - threshold);
  float hsv[3];
 
  /* Extract all colors. */
  CTX_DATA_BEGIN (C, bGPDlayer *, gpl, editable_gpencil_layers) {
    LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
      LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
        if (ED_gpencil_stroke_can_use(C, gps) == false) {
          continue;
        }
        if (ED_gpencil_stroke_material_editable(ob, gpl, gps) == false) {
          continue;
        }
        if ((gps->flag & GP_STROKE_SELECT) == 0) {
          continue;
        }
 
        /* Read all points to get all colors selected. */
        bGPDspoint *pt;
        int i;
        for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
          if (((pt->flag & GP_SPOINT_SELECT) == 0) || (pt->vert_color[3] == 0.0f)) {
            continue;
          }
          /* Round Hue value. */
          rgb_to_hsv_compat_v(pt->vert_color, hsv);
          uint key = truncf(hsv[0] * range);
          if (!BLI_ghash_haskey(hue_table, POINTER_FROM_INT(key))) {
            BLI_ghash_insert(hue_table, POINTER_FROM_INT(key), POINTER_FROM_INT(key));
          }
        }
      }
    }
  }
  CTX_DATA_END;
}
 
static bool gpencil_select_vertex_color_poll(bContext *C)
{
  ToolSettings *ts = CTX_data_tool_settings(C);
  Object *ob = CTX_data_active_object(C);
  if ((ob == NULL) || (ob->type != OB_GPENCIL)) {
    return false;
  }
  bGPdata *gpd = (bGPdata *)ob->data;
 
  if (GPENCIL_VERTEX_MODE(gpd)) {
    if (!(GPENCIL_ANY_VERTEX_MASK(ts->gpencil_selectmode_vertex))) {
      return false;
    }
 
    /* Any data to use. */
    if (gpd->layers.first) {
      return true;
    }
  }
 
  return false;
}
 
static int gpencil_select_vertex_color_exec(bContext *C, wmOperator *op)
{
  ToolSettings *ts = CTX_data_tool_settings(C);
  Object *ob = CTX_data_active_object(C);
  bGPdata *gpd = ED_gpencil_data_get_active(C);
 
  const float threshold = RNA_int_get(op->ptr, "threshold");
  const int selectmode = gpencil_select_mode_from_vertex(ts->gpencil_selectmode_vertex);
  const float range = pow(10, 5 - threshold);
 
  bool changed = false;
 
  /* Create a hash table with all selected colors. */
  GHash *hue_table = BLI_ghash_int_new(__func__);
  gpencil_selected_hue_table(C, ob, threshold, hue_table);
  if (BLI_ghash_len(hue_table) == 0) {
    BKE_report(op->reports, RPT_ERROR, "Select before some Vertex to use as a filter color");
    BLI_ghash_free(hue_table, NULL, NULL);
 
    return OPERATOR_CANCELLED;
  }
 
  /* Select any visible stroke that uses any of these colors. */
  CTX_DATA_BEGIN (C, bGPDstroke *, gps, editable_gpencil_strokes) {
    bGPDspoint *pt;
    int i;
    bool gps_selected = false;
    /* Check all stroke points. */
    for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
      if (pt->vert_color[3] == 0.0f) {
        continue;
      }
 
      /* Only check Hue to get value and saturation full ranges. */
      float hsv[3];
      /* Round Hue value. */
      rgb_to_hsv_compat_v(pt->vert_color, hsv);
      uint key = truncf(hsv[0] * range);
 
      if (BLI_ghash_haskey(hue_table, POINTER_FROM_INT(key))) {
        pt->flag |= GP_SPOINT_SELECT;
        gps_selected = true;
      }
    }
 
    if (gps_selected) {
      gps->flag |= GP_STROKE_SELECT;
      BKE_gpencil_stroke_select_index_set(gpd, gps);
 
      /* Extend stroke selection. */
      if (selectmode == GP_SELECTMODE_STROKE) {
        bGPDspoint *pt1 = NULL;
 
        for (i = 0, pt1 = gps->points; i < gps->totpoints; i++, pt1++) {
          pt1->flag |= GP_SPOINT_SELECT;
        }
      }
    }
  }
  CTX_DATA_END;
 
  if (changed) {
    /* updates */
    DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
 
    /* copy on write tag is needed, or else no refresh happens */
    DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
 
    WM_event_add_notifier(C, NC_GPENCIL | NA_SELECTED, NULL);
    WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
  }
 
  /* Free memory. */
  if (hue_table != NULL) {
    BLI_ghash_free(hue_table, NULL, NULL);
  }
 
  return OPERATOR_FINISHED;
}
 
void GPENCIL_OT_select_vertex_color(wmOperatorType *ot)
{
  PropertyRNA *prop;
 
  /* identifiers */
  ot->name = "Select Vertex Color";
  ot->idname = "GPENCIL_OT_select_vertex_color";
  ot->description = "Select all points with similar vertex color of current selected";
 
  /* callbacks */
  ot->exec = gpencil_select_vertex_color_exec;
  ot->poll = gpencil_select_vertex_color_poll;
 
  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
  /* properties */
  prop = RNA_def_int(
      ot->srna,
      "threshold",
      0,
      0,
      5,
      "Threshold",
      "Tolerance of the selection. Higher values select a wider range of similar colors",
      0,
      5);
  /* avoid re-using last var */
  RNA_def_property_flag(prop, PROP_SKIP_SAVE);
}