source/blender/editors/grease_pencil/intern/grease_pencil_frames.cc

@@ -21,6 +21,7 @@
 
 #include "ANIM_keyframing.hh"
 
+#include "ED_anim_api.hh"
 #include "ED_grease_pencil.hh"
 #include "ED_keyframes_edit.hh"
 #include "ED_markers.hh"
@@ -431,6 +432,200 @@ static void GREASE_PENCIL_OT_insert_blank_frame(wmOperatorType *ot)
   RNA_def_int(ot->srna, "duration", 0, 0, MAXFRAME, "Duration", "", 0, 100);
 }
 
+bool grease_pencil_copy_keyframes(bAnimContext *ac, KeyframeClipboard &clipboard)
+{
+  using namespace bke::greasepencil;
+
+  /* Clear buffer first. */
+  clipboard.clear();
+
+  /* Filter data. */
+  const int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_NODUPLIS);
+  ListBase anim_data = {nullptr, nullptr};
+
+  ANIM_animdata_filter(
+      ac, &anim_data, eAnimFilter_Flags(filter), ac->data, eAnimCont_Types(ac->datatype));
+
+  LISTBASE_FOREACH (bAnimListElem *, ale, &anim_data) {
+    /* This function only deals with grease pencil layer frames.
+     * This check is needed in the case of a call from the main dopesheet. */
+    if (ale->type != ANIMTYPE_GREASE_PENCIL_LAYER) {
+      continue;
+    }
+
+    GreasePencil *grease_pencil = reinterpret_cast<GreasePencil *>(ale->id);
+    Layer *layer = reinterpret_cast<Layer *>(ale->data);
+    Vector<KeyframeClipboard::DrawingBufferItem> buf;
+    FramesMapKey layer_first_frame = std::numeric_limits<int>::max();
+    FramesMapKey layer_last_frame = std::numeric_limits<int>::min();
+    for (auto [frame_number, frame] : layer->frames().items()) {
+      if (frame.is_selected()) {
+        const Drawing *drawing = grease_pencil->get_drawing_at(*layer, frame_number);
+        const int duration = frame.is_implicit_hold() ? 0 :
+                                                        layer->get_frame_duration_at(frame_number);
+        buf.append({frame_number, Drawing(*drawing), duration});
+
+        /* Check the range of this layer only. */
+        if (frame_number < layer_first_frame) {
+          layer_first_frame = frame_number;
+        }
+        if (frame_number > layer_last_frame) {
+          layer_last_frame = frame_number;
+        }
+      }
+    }
+    if (!buf.is_empty()) {
+      BLI_assert(!clipboard.copy_buffer.contains(layer->name()));
+      clipboard.copy_buffer.add_new(layer->name(), {buf, layer_first_frame, layer_last_frame});
+      /* Update the range of entire copy buffer. */
+      if (layer_first_frame < clipboard.first_frame) {
+        clipboard.first_frame = layer_first_frame;
+      }
+      if (layer_last_frame > clipboard.last_frame) {
+        clipboard.last_frame = layer_last_frame;
+      }
+    }
+  }
+
+  /* In case 'relative' paste method is used. */
+  clipboard.cfra = ac->scene->r.cfra;
+
+  /* Clean up. */
+  ANIM_animdata_freelist(&anim_data);
+
+  /* If nothing ended up in the buffer, copy failed. */
+  return !clipboard.copy_buffer.is_empty();
+}
+
+static int calculate_offset(const eKeyPasteOffset offset_mode,
+                            const int cfra,
+                            const KeyframeClipboard &clipboard)
+{
+  int offset = 0;
+  switch (offset_mode) {
+    case KEYFRAME_PASTE_OFFSET_CFRA_START:
+      offset = (cfra - clipboard.first_frame);
+      break;
+    case KEYFRAME_PASTE_OFFSET_CFRA_END:
+      offset = (cfra - clipboard.last_frame);
+      break;
+    case KEYFRAME_PASTE_OFFSET_CFRA_RELATIVE:
+      offset = (cfra - clipboard.cfra);
+      break;
+    case KEYFRAME_PASTE_OFFSET_NONE:
+      offset = 0;
+      break;
+  }
+  return offset;
+}
+
+bool grease_pencil_paste_keyframes(bAnimContext *ac,
+                                   const eKeyPasteOffset offset_mode,
+                                   const eKeyMergeMode merge_mode,
+                                   const KeyframeClipboard &clipboard)
+{
+  using namespace bke::greasepencil;
+
+  /* Check if buffer is empty. */
+  if (clipboard.copy_buffer.is_empty()) {
+    return false;
+  }
+
+  const int offset = calculate_offset(offset_mode, ac->scene->r.cfra, clipboard);
+
+  const int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_NODUPLIS |
+                      ANIMFILTER_FOREDIT | ANIMFILTER_SEL);
+  ListBase anim_data = {nullptr, nullptr};
+
+  ANIM_animdata_filter(
+      ac, &anim_data, eAnimFilter_Flags(filter), ac->data, eAnimCont_Types(ac->datatype));
+
+  /* Check if single channel in buffer (disregard names if so). */
+  const bool from_single_channel = clipboard.copy_buffer.size() == 1;
+
+  LISTBASE_FOREACH (bAnimListElem *, ale, &anim_data) {
+    /* Only deal with GPlayers (case of calls from general dopesheet). */
+    if (ale->type != ANIMTYPE_GREASE_PENCIL_LAYER) {
+      continue;
+    }
+    GreasePencil *grease_pencil = reinterpret_cast<GreasePencil *>(ale->id);
+    Layer *layer = reinterpret_cast<Layer *>(ale->data);
+    const std::string layer_name = layer->name();
+    if (!from_single_channel && !clipboard.copy_buffer.contains(layer_name)) {
+      continue;
+    }
+    KeyframeClipboard::LayerBufferItem layer_buffer = from_single_channel ?
+                                                          *clipboard.copy_buffer.values().begin() :
+                                                          clipboard.copy_buffer.lookup(layer_name);
+    bool change = false;
+
+    /* Mix mode with existing data. */
+    switch (merge_mode) {
+      case KEYFRAME_PASTE_MERGE_MIX:
+        /* Do nothing. */
+        break;
+
+      case KEYFRAME_PASTE_MERGE_OVER: {
+        /* Remove all keys. */
+        Vector<int> frames_to_remove;
+        for (auto frame_number : layer->frames().keys()) {
+          frames_to_remove.append(frame_number);
+        }
+        grease_pencil->remove_frames(*layer, frames_to_remove);
+        change = true;
+        break;
+      }
+      case KEYFRAME_PASTE_MERGE_OVER_RANGE:
+      case KEYFRAME_PASTE_MERGE_OVER_RANGE_ALL: {
+        int frame_min, frame_max;
+
+        if (merge_mode == KEYFRAME_PASTE_MERGE_OVER_RANGE) {
+          /* Entire range of this layer. */
+          frame_min = layer_buffer.first_frame + offset;
+          frame_max = layer_buffer.last_frame + offset;
+        }
+        else {
+          /* Entire range of all copied keys. */
+          frame_min = clipboard.first_frame + offset;
+          frame_max = clipboard.last_frame + offset;
+        }
+
+        /* Remove keys in range. */
+        if (frame_min < frame_max) {
+          Vector<int> frames_to_remove;
+          for (auto frame_number : layer->frames().keys()) {
+            if (frame_min < frame_number && frame_number < frame_max) {
+              frames_to_remove.append(frame_number);
+            }
+          }
+          grease_pencil->remove_frames(*layer, frames_to_remove);
+          change = true;
+        }
+        break;
+      }
+    }
+    for (KeyframeClipboard::DrawingBufferItem drawing_buffer : layer_buffer.drawing_buffers) {
+      const int target_frame_number = drawing_buffer.frame_number + offset;
+      if (layer->frames().contains(target_frame_number)) {
+        layer->remove_frame(target_frame_number);
+      }
+      layer->add_frame(
+          target_frame_number, grease_pencil->drawings().size(), drawing_buffer.duration);
+      grease_pencil->add_duplicate_drawings(1, drawing_buffer.drawing);
+      change = true;
+    }
+
+    if (change) {
+      DEG_id_tag_update(&grease_pencil->id, ID_RECALC_GEOMETRY);
+    }
+  }
+
+  /* Clean up. */
+  ANIM_animdata_freelist(&anim_data);
+
+  return true;
+}
+
 }  // namespace blender::ed::greasepencil
 
 void ED_operatortypes_grease_pencil_frames()

source/blender/editors/include/ED_grease_pencil.hh

@@ -131,6 +131,41 @@ bool remove_all_selected_frames(GreasePencil &grease_pencil, bke::greasepencil::
 
 void select_layer_channel(GreasePencil &grease_pencil, bke::greasepencil::Layer *layer);
 
+struct KeyframeClipboard {
+  /* Datatype for use in copy/paste buffer. */
+  struct DrawingBufferItem {
+    blender::bke::greasepencil::FramesMapKey frame_number;
+    bke::greasepencil::Drawing drawing;
+    int duration;
+  };
+
+  struct LayerBufferItem {
+    Vector<DrawingBufferItem> drawing_buffers;
+    blender::bke::greasepencil::FramesMapKey first_frame;
+    blender::bke::greasepencil::FramesMapKey last_frame;
+  };
+
+  Map<std::string, LayerBufferItem> copy_buffer{};
+  int first_frame{std::numeric_limits<int>::max()};
+  int last_frame{std::numeric_limits<int>::min()};
+  int cfra{0};
+
+  void clear()
+  {
+    copy_buffer.clear();
+    first_frame = std::numeric_limits<int>::max();
+    last_frame = std::numeric_limits<int>::min();
+    cfra = 0;
+  }
+};
+
+bool grease_pencil_copy_keyframes(bAnimContext *ac, KeyframeClipboard &clipboard);
+
+bool grease_pencil_paste_keyframes(bAnimContext *ac,
+                                   const eKeyPasteOffset offset_mode,
+                                   const eKeyMergeMode merge_mode,
+                                   const KeyframeClipboard &clipboard);
+
 /**
  * Sets the selection flag, according to \a selection_mode to the frame at \a frame_number in the
  * \a layer if such frame exists. Returns false if no such frame exists.

source/blender/editors/space_action/action_edit.cc

@@ -576,6 +576,12 @@ static eKeyPasteError paste_action_keys(bAnimContext *ac,
 
 /* ------------------- */
 
+static blender::ed::greasepencil::KeyframeClipboard &get_grease_pencil_keyframe_clipboard()
+{
+  static blender::ed::greasepencil::KeyframeClipboard clipboard;
+  return clipboard;
+}
+
 static int actkeys_copy_exec(bContext *C, wmOperator *op)
 {
   bAnimContext ac;
@@ -587,7 +593,10 @@ static int actkeys_copy_exec(bContext *C, wmOperator *op)
 
   /* copy keyframes */
   if (ac.datatype == ANIMCONT_GPENCIL) {
-    if (ED_gpencil_anim_copybuf_copy(&ac) == false) {
+    if (ED_gpencil_anim_copybuf_copy(&ac) == false &&
+        blender::ed::greasepencil::grease_pencil_copy_keyframes(
+            &ac, get_grease_pencil_keyframe_clipboard()) == false)
+    {
       /* check if anything ended up in the buffer */
       BKE_report(op->reports, RPT_ERROR, "No keyframes copied to the internal clipboard");
       return OPERATOR_CANCELLED;
@@ -601,7 +610,9 @@ static int actkeys_copy_exec(bContext *C, wmOperator *op)
   else {
     /* Both copy function needs to be evaluated to account for mixed selection */
     const short kf_empty = copy_action_keys(&ac);
-    const bool gpf_ok = ED_gpencil_anim_copybuf_copy(&ac);
+    const bool gpf_ok = ED_gpencil_anim_copybuf_copy(&ac) ||
+                        blender::ed::greasepencil::grease_pencil_copy_keyframes(
+                            &ac, get_grease_pencil_keyframe_clipboard());
 
     if (kf_empty && !gpf_ok) {
       BKE_report(op->reports, RPT_ERROR, "No keyframes copied to the internal clipboard");
@@ -647,7 +658,10 @@ static int actkeys_paste_exec(bContext *C, wmOperator *op)
 
   /* paste keyframes */
   if (ac.datatype == ANIMCONT_GPENCIL) {
-    if (ED_gpencil_anim_copybuf_paste(&ac, offset_mode) == false) {
+    if (ED_gpencil_anim_copybuf_paste(&ac, offset_mode) == false &&
+        blender::ed::greasepencil::grease_pencil_paste_keyframes(
+            &ac, offset_mode, merge_mode, get_grease_pencil_keyframe_clipboard()) == false)
+    {
       BKE_report(op->reports, RPT_ERROR, "No data in the internal clipboard to paste");
       return OPERATOR_CANCELLED;
     }
@@ -663,7 +677,9 @@ static int actkeys_paste_exec(bContext *C, wmOperator *op)
     /* Both paste function needs to be evaluated to account for mixed selection */
     const eKeyPasteError kf_empty = paste_action_keys(&ac, offset_mode, merge_mode, flipped);
     /* non-zero return means an error occurred while trying to paste */
-    gpframes_inbuf = ED_gpencil_anim_copybuf_paste(&ac, offset_mode);
+    gpframes_inbuf = ED_gpencil_anim_copybuf_paste(&ac, offset_mode) ||
+                     blender::ed::greasepencil::grease_pencil_paste_keyframes(
+                         &ac, offset_mode, merge_mode, get_grease_pencil_keyframe_clipboard());
 
     /* Only report an error if nothing was pasted, i.e. when both FCurve and GPencil failed. */
     if (!gpframes_inbuf) {