From 98d3d64085bfc15608f182bee4c37c6be7d2ca2d Mon Sep 17 00:00:00 2001
From: Daria Volvenkova <d.volvenkova@corp.mail.ru>
Date: Wed, 26 Jul 2017 14:50:35 +0300
Subject: [PATCH] User marks animation refactoring.

---
 drape_frontend/backend_renderer.cpp    |  46 ++++++-----
 drape_frontend/drape_engine.cpp        |  56 ++++++++++----
 drape_frontend/drape_engine.hpp        |   7 +-
 drape_frontend/message.hpp             |   8 +-
 drape_frontend/message_subclasses.hpp  | 101 +++++++++++++++----------
 drape_frontend/user_mark_generator.cpp |  35 ++++++---
 drape_frontend/user_mark_generator.hpp |  20 +++--
 drape_frontend/user_mark_shapes.cpp    |  11 +--
 drape_frontend/user_mark_shapes.hpp    |  21 ++---
 drape_frontend/user_marks_provider.cpp |   4 +-
 drape_frontend/user_marks_provider.hpp |  33 ++++++--
 map/api_mark_point.cpp                 |  18 +++++
 map/api_mark_point.hpp                 |   8 +-
 map/bookmark.cpp                       |  19 ++---
 map/bookmark.hpp                       |   4 +-
 map/bookmark_manager.cpp               |   1 -
 map/framework.cpp                      |   6 +-
 map/map_tests/mwm_url_tests.cpp        |   2 +-
 map/mwm_url.cpp                        |   2 +-
 map/user_mark.cpp                      |   5 --
 map/user_mark.hpp                      |   2 +-
 map/user_mark_container.cpp            |  42 ++++++----
 map/user_mark_container.hpp            |   6 +-
 23 files changed, 277 insertions(+), 180 deletions(-)

diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index d885bbe8e9..fae7d63592 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -257,41 +257,45 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       break;
     }
 
-  case Message::ChangeUserMarkLayerVisibility:
+  case Message::ChangeUserMarkGroupVisibility:
     {
-      ref_ptr<ChangeUserMarkLayerVisibilityMessage> msg = message;
-      m_userMarkGenerator->SetGroupVisibility(static_cast<GroupID>(msg->GetLayerId()), msg->IsVisible());
-      m_commutator->PostMessage(ThreadsCommutator::RenderThread,
-                                make_unique_dp<InvalidateUserMarksMessage>(msg->GetLayerId()),
-                                MessagePriority::Normal);
+      ref_ptr<ChangeUserMarkGroupVisibilityMessage> msg = message;
+      m_userMarkGenerator->SetGroupVisibility(msg->GetGroupId(), msg->IsVisible());
       break;
     }
 
-  case Message::UpdateUserMarkLayer:
+  case Message::UpdateUserMarks:
     {
-      ref_ptr<UpdateUserMarkLayerMessage> msg = message;
-      size_t const layerId = msg->GetLayerId();
-      m_userMarkGenerator->RemoveUserMarks(msg->AcceptRemovedIds());
+      ref_ptr<UpdateUserMarksMessage> msg = message;
+      m_userMarkGenerator->SetRemovedUserMarks(msg->AcceptRemovedIds());
       m_userMarkGenerator->SetUserMarks(msg->AcceptMarkRenderParams());
       m_userMarkGenerator->SetUserLines(msg->AcceptLineRenderParams());
-      m_userMarkGenerator->SetGroup(msg->GetLayerId(), msg->AcceptIds());
-      m_commutator->PostMessage(ThreadsCommutator::RenderThread,
-                                make_unique_dp<InvalidateUserMarksMessage>(layerId),
-                                MessagePriority::Normal);
+      m_userMarkGenerator->SetCreatedUserMarks(msg->AcceptCreatedIds());
       break;
     }
 
-  case Message::ClearUserMarkLayer:
+  case Message::UpdateUserMarkGroup:
     {
-      ref_ptr<ClearUserMarkLayerMessage> msg = message;
-      size_t const layerId = msg->GetLayerId();
-      m_userMarkGenerator->RemoveGroup(static_cast<GroupID>(layerId));
-      m_commutator->PostMessage(ThreadsCommutator::RenderThread,
-                                make_unique_dp<InvalidateUserMarksMessage>(layerId),
-                                MessagePriority::Normal);
+      ref_ptr<UpdateUserMarkGroupMessage> msg = message;
+      MarkGroupID const groupId = msg->GetGroupId();
+      m_userMarkGenerator->SetGroup(groupId, msg->AcceptIds());
       break;
     }
 
+  case Message::ClearUserMarkGroup:
+    {
+      ref_ptr<ClearUserMarkGroupMessage> msg = message;
+      m_userMarkGenerator->RemoveGroup(msg->GetGroupId());
+      break;
+    }
+
+  case Message::InvalidateUserMarks:
+    {
+      m_commutator->PostMessage(ThreadsCommutator::RenderThread,
+                                make_unique_dp<InvalidateUserMarksMessage>(),
+                                MessagePriority::Normal);
+      break;
+    }
   case Message::AddSubroute:
     {
       ref_ptr<AddSubrouteMessage> msg = message;
diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp
index c94652ad8b..a63012d6a0 100644
--- a/drape_frontend/drape_engine.cpp
+++ b/drape_frontend/drape_engine.cpp
@@ -193,30 +193,40 @@ void DrapeEngine::SetModelViewAnyRect(m2::AnyRectD const & rect, bool isAnim)
   AddUserEvent(make_unique_dp<SetAnyRectEvent>(rect, isAnim));
 }
 
-void DrapeEngine::ClearUserMarksLayer(size_t layerId)
+void DrapeEngine::ClearUserMarksGroup(size_t layerId)
 {
   m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
-                                  make_unique_dp<ClearUserMarkLayerMessage>(layerId),
+                                  make_unique_dp<ClearUserMarkGroupMessage>(layerId),
                                   MessagePriority::Normal);
 }
 
-void DrapeEngine::ChangeVisibilityUserMarksLayer(size_t layerId, bool isVisible)
+void DrapeEngine::ChangeVisibilityUserMarksGroup(MarkGroupID groupId, bool isVisible)
 {
   m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
-                                  make_unique_dp<ChangeUserMarkLayerVisibilityMessage>(layerId, isVisible),
+                                  make_unique_dp<ChangeUserMarkGroupVisibilityMessage>(groupId, isVisible),
                                   MessagePriority::Normal);
 }
 
-void DrapeEngine::UpdateUserMarksLayer(size_t layerId, UserMarksProvider * provider)
+void DrapeEngine::InvalidateUserMarks()
 {
+  m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                  make_unique_dp<InvalidateUserMarksMessage>(),
+                                  MessagePriority::Normal);
+}
+
+void DrapeEngine::UpdateUserMarksGroup(MarkGroupID groupId, UserMarksProvider * provider)
+{
+  auto groupIdCollection = make_unique_dp<MarkIDCollection>();
+  auto removedIdCollection = make_unique_dp<MarkIDCollection>();
+  auto createdIdCollection = make_unique_dp<MarkIDCollection>();
+
   auto marksRenderCollection = make_unique_dp<UserMarksRenderCollection>();
-  auto idCollection = make_unique_dp<IDCollection>();
-  auto removedIdCollection = make_unique_dp<IDCollection>();
   marksRenderCollection->reserve(provider->GetUserPointCount());
+
   for (size_t pointIndex = 0, sz = provider->GetUserPointCount(); pointIndex < sz; ++pointIndex)
   {
     UserPointMark const * mark = provider->GetUserPointMark(pointIndex);
-    idCollection->m_marksID.push_back(mark->GetId());
+    groupIdCollection->m_marksID.push_back(mark->GetId());
     if (mark->IsDirty())
     {
       auto renderInfo = make_unique_dp<UserMarkRenderParams>();
@@ -227,13 +237,14 @@ void DrapeEngine::UpdateUserMarksLayer(size_t layerId, UserMarksProvider * provi
       renderInfo->m_isVisible = mark->IsVisible();
       renderInfo->m_pivot = mark->GetPivot();
       renderInfo->m_pixelOffset = mark->GetPixelOffset();
-      renderInfo->m_runCreationAnim = mark->HasCreationAnimation();
       renderInfo->m_symbolName = mark->GetSymbolName();
       renderInfo->m_titleDecl = mark->GetTitleDecl();
       renderInfo->m_hasSymbolPriority = mark->HasSymbolPriority();
       renderInfo->m_hasTitlePriority = mark->HasTitlePriority();
       renderInfo->m_priority = mark->GetPriority();
       renderInfo->m_featureId = mark->GetFeatureID();
+      renderInfo->m_runCreationAnim = mark->RunCreationAnim();
+
       marksRenderCollection->emplace(mark->GetId(), std::move(renderInfo));
       mark->AcceptChanges();
     }
@@ -244,7 +255,7 @@ void DrapeEngine::UpdateUserMarksLayer(size_t layerId, UserMarksProvider * provi
   for (size_t lineIndex = 0, sz = provider->GetUserLineCount(); lineIndex < sz; ++lineIndex)
   {
     UserLineMark const * mark = provider->GetUserLineMark(lineIndex);
-    idCollection->m_linesID.push_back(mark->GetId());
+    groupIdCollection->m_linesID.push_back(mark->GetId());
     if (mark->IsDirty())
     {
       auto renderInfo = make_unique_dp<UserLineRenderParams>();
@@ -258,17 +269,30 @@ void DrapeEngine::UpdateUserMarksLayer(size_t layerId, UserMarksProvider * provi
                                           mark->GetWidth(layerIndex),
                                           mark->GetDepth(layerIndex));
       }
+
       linesRenderCollection->emplace(mark->GetId(), std::move(renderInfo));
       mark->AcceptChanges();
     }
   }
-  provider->AcceptChanges(removedIdCollection->m_marksID);
+
+  provider->AcceptChanges(*createdIdCollection, *removedIdCollection);
+
+  if (!createdIdCollection->IsEmpty() || !removedIdCollection->IsEmpty() ||
+      !marksRenderCollection->empty() || !linesRenderCollection->empty())
+  {
+    m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                    make_unique_dp<UpdateUserMarksMessage>(
+                                      std::move(createdIdCollection),
+                                      std::move(removedIdCollection),
+                                      std::move(marksRenderCollection),
+                                      std::move(linesRenderCollection)),
+                                    MessagePriority::Normal);
+  }
+
   m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
-                                  make_unique_dp<UpdateUserMarkLayerMessage>(layerId,
-                                                                             std::move(idCollection),
-                                                                             std::move(removedIdCollection),
-                                                                             std::move(marksRenderCollection),
-                                                                             std::move(linesRenderCollection)),
+                                  make_unique_dp<UpdateUserMarkGroupMessage>(
+                                    groupId,
+                                    std::move(groupIdCollection)),
                                   MessagePriority::Normal);
 }
 
diff --git a/drape_frontend/drape_engine.hpp b/drape_frontend/drape_engine.hpp
index a02d201b6e..3aff8328c8 100644
--- a/drape_frontend/drape_engine.hpp
+++ b/drape_frontend/drape_engine.hpp
@@ -130,9 +130,10 @@ public:
   using TModelViewListenerFn = FrontendRenderer::TModelViewChanged;
   void SetModelViewListener(TModelViewListenerFn && fn);
 
-  void ClearUserMarksLayer(size_t layerId);
-  void ChangeVisibilityUserMarksLayer(size_t layerId, bool isVisible);
-  void UpdateUserMarksLayer(size_t layerId, UserMarksProvider * provider);
+  void ClearUserMarksGroup(size_t layerId);
+  void ChangeVisibilityUserMarksGroup(MarkGroupID groupId, bool isVisible);
+  void UpdateUserMarksGroup(MarkGroupID groupId, UserMarksProvider * provider);
+  void InvalidateUserMarks();
 
   void SetRenderingEnabled(ref_ptr<dp::OGLContextFactory> contextFactory = nullptr);
   void SetRenderingDisabled(bool const destroyContext);
diff --git a/drape_frontend/message.hpp b/drape_frontend/message.hpp
index 911739e7bd..0f7ae1b0fe 100644
--- a/drape_frontend/message.hpp
+++ b/drape_frontend/message.hpp
@@ -20,9 +20,11 @@ public:
     UpdateReadManager,
     InvalidateRect,
     InvalidateReadManagerRect,
-    ClearUserMarkLayer,
-    ChangeUserMarkLayerVisibility,
-    UpdateUserMarkLayer,
+    UpdateUserMarkGroup,
+    ClearUserMarkGroup,
+    ChangeUserMarkGroupVisibility,
+    UpdateUserMarks,
+    SetCreatedUserMarks,
     InvalidateUserMarks,
     FlushUserMarks,
     GuiLayerRecached,
diff --git a/drape_frontend/message_subclasses.hpp b/drape_frontend/message_subclasses.hpp
index 7acdf7972f..af3a5ddd47 100644
--- a/drape_frontend/message_subclasses.hpp
+++ b/drape_frontend/message_subclasses.hpp
@@ -199,70 +199,97 @@ private:
   bool m_needInvalidateAll;
 };
 
-class BaseUserMarkLayerMessage : public Message
+class ClearUserMarkGroupMessage : public Message
 {
 public:
-  BaseUserMarkLayerMessage(size_t layerId)
-    : m_layerId(layerId)
+  ClearUserMarkGroupMessage(MarkGroupID groupId)
+    : m_groupId(groupId)
   {}
 
-  size_t GetLayerId() const { return m_layerId; }
+  Type GetType() const override { return Message::ClearUserMarkGroup; }
+
+  MarkGroupID GetGroupId() const { return m_groupId; }
 
 private:
-  size_t m_layerId;
+  MarkGroupID m_groupId;
 };
 
-class ClearUserMarkLayerMessage : public BaseUserMarkLayerMessage
+class ChangeUserMarkGroupVisibilityMessage : public Message
 {
 public:
-  ClearUserMarkLayerMessage(size_t layerId)
-    : BaseUserMarkLayerMessage(layerId) {}
-
-  Type GetType() const override { return Message::ClearUserMarkLayer; }
-};
-
-class ChangeUserMarkLayerVisibilityMessage : public BaseUserMarkLayerMessage
-{
-public:
-  ChangeUserMarkLayerVisibilityMessage(size_t layerId, bool isVisible)
-    : BaseUserMarkLayerMessage(layerId)
+  ChangeUserMarkGroupVisibilityMessage(MarkGroupID groupId, bool isVisible)
+    : m_groupId(groupId)
     , m_isVisible(isVisible) {}
 
-  Type GetType() const override { return Message::ChangeUserMarkLayerVisibility; }
+  Type GetType() const override { return Message::ChangeUserMarkGroupVisibility; }
 
+  MarkGroupID GetGroupId() const { return m_groupId; }
   bool IsVisible() const { return m_isVisible; }
 
 private:
+  MarkGroupID m_groupId;
   bool m_isVisible;
 };
 
-class UpdateUserMarkLayerMessage : public BaseUserMarkLayerMessage
+class AnimateUserMarksMessage : public Message
 {
 public:
-  UpdateUserMarkLayerMessage(size_t layerId,
-                             drape_ptr<IDCollection> && ids,
-                             drape_ptr<IDCollection> && removedIds,
-                             drape_ptr<UserMarksRenderCollection> && marksRenderParams,
-                             drape_ptr<UserLinesRenderCollection> && linesRenderParams)
-    : BaseUserMarkLayerMessage(layerId)
-    , m_marksRenderParams(std::move(marksRenderParams))
-    , m_linesRenderParams(std::move(linesRenderParams))
-    , m_ids(std::move(ids))
-    , m_removedIds(std::move(removedIds))
+  AnimateUserMarksMessage(drape_ptr<MarkIDCollection> && ids)
+    : m_ids(std::move(ids))
   {}
 
-  Type GetType() const override { return Message::UpdateUserMarkLayer; }
+  Type GetType() const override { return Message::SetCreatedUserMarks; }
+
+  drape_ptr<MarkIDCollection> && AcceptIds() { return std::move(m_ids); }
+
+private:
+  drape_ptr<MarkIDCollection> m_ids;
+};
+
+class UpdateUserMarksMessage : public Message
+{
+public:
+  UpdateUserMarksMessage(drape_ptr<MarkIDCollection> && createdIds,
+                         drape_ptr<MarkIDCollection> && removedIds,
+                         drape_ptr<UserMarksRenderCollection> && marksRenderParams,
+                         drape_ptr<UserLinesRenderCollection> && linesRenderParams)
+    : m_createdIds(std::move(createdIds))
+    , m_removedIds(std::move(removedIds))
+    , m_marksRenderParams(std::move(marksRenderParams))
+    , m_linesRenderParams(std::move(linesRenderParams))
+  {}
+
+  Type GetType() const override { return Message::UpdateUserMarks; }
 
   drape_ptr<UserMarksRenderCollection> && AcceptMarkRenderParams() { return std::move(m_marksRenderParams); }
   drape_ptr<UserLinesRenderCollection> && AcceptLineRenderParams() { return std::move(m_linesRenderParams); }
-  drape_ptr<IDCollection> && AcceptIds() { return std::move(m_ids); }
-  drape_ptr<IDCollection> && AcceptRemovedIds() { return std::move(m_removedIds); }
+  drape_ptr<MarkIDCollection> && AcceptRemovedIds() { return std::move(m_removedIds); }
+  drape_ptr<MarkIDCollection> && AcceptCreatedIds() { return std::move(m_createdIds); }
 
 private:
+  drape_ptr<MarkIDCollection> m_createdIds;
+  drape_ptr<MarkIDCollection> m_removedIds;
   drape_ptr<UserMarksRenderCollection> m_marksRenderParams;
   drape_ptr<UserLinesRenderCollection> m_linesRenderParams;
-  drape_ptr<IDCollection> m_ids;
-  drape_ptr<IDCollection> m_removedIds;
+};
+
+class UpdateUserMarkGroupMessage : public Message
+{
+public:
+  UpdateUserMarkGroupMessage(MarkGroupID groupId,
+                             drape_ptr<MarkIDCollection> && ids)
+    : m_groupId(groupId)
+    , m_ids(std::move(ids))
+  {}
+
+  Type GetType() const override { return Message::UpdateUserMarkGroup; }
+
+  MarkGroupID GetGroupId() const { return m_groupId; }
+  drape_ptr<MarkIDCollection> && AcceptIds() { return std::move(m_ids); }
+
+private:
+  MarkGroupID m_groupId;
+  drape_ptr<MarkIDCollection> m_ids;
 };
 
 class FlushUserMarksMessage : public Message
@@ -281,12 +308,10 @@ private:
   TUserMarksRenderData m_renderData;
 };
 
-class InvalidateUserMarksMessage : public BaseUserMarkLayerMessage
+class InvalidateUserMarksMessage : public Message
 {
 public:
-  InvalidateUserMarksMessage(size_t layerId)
-    : BaseUserMarkLayerMessage(layerId)
-  {}
+  InvalidateUserMarksMessage() = default;
 
   Type GetType() const override { return Message::InvalidateUserMarks; }
 };
diff --git a/drape_frontend/user_mark_generator.cpp b/drape_frontend/user_mark_generator.cpp
index d36ba8de1a..d18855c351 100644
--- a/drape_frontend/user_mark_generator.cpp
+++ b/drape_frontend/user_mark_generator.cpp
@@ -18,20 +18,20 @@ UserMarkGenerator::UserMarkGenerator(TFlushFn const & flushFn)
   ASSERT(m_flushFn != nullptr, ());
 }
 
-void UserMarkGenerator::RemoveGroup(GroupID groupId)
+void UserMarkGenerator::RemoveGroup(MarkGroupID groupId)
 {
   m_groupsVisibility.erase(groupId);
   m_groups.erase(groupId);
   UpdateIndex(groupId);
 }
 
-void UserMarkGenerator::SetGroup(GroupID groupId, drape_ptr<IDCollection> && ids)
+void UserMarkGenerator::SetGroup(MarkGroupID groupId, drape_ptr<MarkIDCollection> && ids)
 {
   m_groups[groupId] = std::move(ids);
   UpdateIndex(groupId);
 }
 
-void UserMarkGenerator::RemoveUserMarks(drape_ptr<IDCollection> && ids)
+void UserMarkGenerator::SetRemovedUserMarks(drape_ptr<MarkIDCollection> && ids)
 {
   if (ids == nullptr)
     return;
@@ -41,6 +41,17 @@ void UserMarkGenerator::RemoveUserMarks(drape_ptr<IDCollection> && ids)
     m_lines.erase(id);
 }
 
+void UserMarkGenerator::SetCreatedUserMarks(drape_ptr<MarkIDCollection> && ids)
+{
+  if (ids == nullptr)
+    return;
+  for (auto const & id : ids->m_marksID)
+  {
+    UserMarkRenderParams & params = *m_marks[id].get();
+    params.m_justCreated = true;
+  }
+}
+
 void UserMarkGenerator::SetUserMarks(drape_ptr<UserMarksRenderCollection> && marks)
 {
   for (auto & pair : *marks.get())
@@ -66,7 +77,7 @@ void UserMarkGenerator::SetUserLines(drape_ptr<UserLinesRenderCollection> && lin
 }
 
 
-void UserMarkGenerator::UpdateIndex(GroupID groupId)
+void UserMarkGenerator::UpdateIndex(MarkGroupID groupId)
 {
   for (auto & tileGroups : m_index)
   {
@@ -82,7 +93,7 @@ void UserMarkGenerator::UpdateIndex(GroupID groupId)
   if (groupIt == m_groups.end())
     return;
 
-  IDCollection & idCollection = *groupIt->second.get();
+  MarkIDCollection & idCollection = *groupIt->second.get();
 
   for (auto markId : idCollection.m_marksID)
   {
@@ -90,7 +101,7 @@ void UserMarkGenerator::UpdateIndex(GroupID groupId)
     for (int zoomLevel = params.m_minZoom; zoomLevel <= scales::GetUpperScale(); ++zoomLevel)
     {
       TileKey const tileKey = GetTileKeyByPoint(params.m_pivot, zoomLevel);
-      ref_ptr<IDCollection> groupIDs = GetIdCollection(tileKey, groupId);
+      ref_ptr<MarkIDCollection> groupIDs = GetIdCollection(tileKey, groupId);
       groupIDs->m_marksID.push_back(static_cast<uint32_t>(markId));
     }
   }
@@ -131,7 +142,7 @@ void UserMarkGenerator::UpdateIndex(GroupID groupId)
         CalcTilesCoverage(splineRect, zoomLevel, [&](int tileX, int tileY)
         {
           TileKey const tileKey(tileX, tileY, zoomLevel);
-          ref_ptr<IDCollection> groupIDs = GetIdCollection(tileKey, groupId);
+          ref_ptr<MarkIDCollection> groupIDs = GetIdCollection(tileKey, groupId);
           groupIDs->m_linesID.push_back(static_cast<uint32_t>(lineId));
         });
       }
@@ -141,7 +152,7 @@ void UserMarkGenerator::UpdateIndex(GroupID groupId)
   CleanIndex();
 }
 
-ref_ptr<IDCollection> UserMarkGenerator::GetIdCollection(TileKey const & tileKey, GroupID groupId)
+ref_ptr<MarkIDCollection> UserMarkGenerator::GetIdCollection(TileKey const & tileKey, MarkGroupID groupId)
 {
   ref_ptr<MarksIDGroups> tileGroups;
   auto itTileGroups = m_index.find(tileKey);
@@ -156,11 +167,11 @@ ref_ptr<IDCollection> UserMarkGenerator::GetIdCollection(TileKey const & tileKey
     tileGroups = make_ref(itTileGroups->second);
   }
 
-  ref_ptr<IDCollection> groupIDs;
+  ref_ptr<MarkIDCollection> groupIDs;
   auto itGroupIDs = tileGroups->find(groupId);
   if (itGroupIDs == tileGroups->end())
   {
-    auto groupMarkIndexes = make_unique_dp<IDCollection>();
+    auto groupMarkIndexes = make_unique_dp<MarkIDCollection>();
     groupIDs = make_ref(groupMarkIndexes);
     tileGroups->insert(make_pair(groupId, std::move(groupMarkIndexes)));
   }
@@ -194,7 +205,7 @@ void UserMarkGenerator::CleanIndex()
   }
 }
 
-void UserMarkGenerator::SetGroupVisibility(GroupID groupId, bool isVisible)
+void UserMarkGenerator::SetGroupVisibility(MarkGroupID groupId, bool isVisible)
 {
   if (isVisible)
     m_groupsVisibility.insert(groupId);
@@ -222,7 +233,7 @@ void UserMarkGenerator::GenerateUserMarksGeometry(TileKey const & tileKey, ref_p
     MarksIDGroups & indexesGroups = *itTile->second;
     for (auto & groupPair : indexesGroups)
     {
-      GroupID groupId = groupPair.first;
+      MarkGroupID groupId = groupPair.first;
 
       if (m_groupsVisibility.find(groupId) == m_groupsVisibility.end())
         continue;
diff --git a/drape_frontend/user_mark_generator.hpp b/drape_frontend/user_mark_generator.hpp
index 5002c6a230..b72c8df71c 100644
--- a/drape_frontend/user_mark_generator.hpp
+++ b/drape_frontend/user_mark_generator.hpp
@@ -12,9 +12,7 @@
 
 namespace df
 {
-using GroupID = size_t;
-
-using MarksIDGroups = std::map<GroupID, drape_ptr<IDCollection>>;
+using MarksIDGroups = std::map<MarkGroupID, drape_ptr<MarkIDCollection>>;
 using MarksIndex = std::map<TileKey, drape_ptr<MarksIDGroups>>;
 
 class UserMarkGenerator
@@ -26,22 +24,22 @@ public:
 
   void SetUserMarks(drape_ptr<UserMarksRenderCollection> && marks);
   void SetUserLines(drape_ptr<UserLinesRenderCollection> && lines);
+  void SetRemovedUserMarks(drape_ptr<MarkIDCollection> && ids);
+  void SetCreatedUserMarks(drape_ptr<MarkIDCollection> && ids);
 
-  void SetGroup(GroupID groupId, drape_ptr<IDCollection> && ids);
-  void RemoveGroup(GroupID groupId);
-  void RemoveUserMarks(drape_ptr<IDCollection> && ids);
-
-  void SetGroupVisibility(GroupID groupId, bool isVisible);
+  void SetGroup(MarkGroupID groupId, drape_ptr<MarkIDCollection> && ids);
+  void RemoveGroup(MarkGroupID groupId);
+  void SetGroupVisibility(MarkGroupID groupId, bool isVisible);
 
   void GenerateUserMarksGeometry(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures);
 
 private:
-  void UpdateIndex(GroupID groupId);
+  void UpdateIndex(MarkGroupID groupId);
 
-  ref_ptr<IDCollection> GetIdCollection(TileKey const & tileKey, GroupID groupId);
+  ref_ptr<MarkIDCollection> GetIdCollection(TileKey const & tileKey, MarkGroupID groupId);
   void CleanIndex();
 
-  std::unordered_set<GroupID> m_groupsVisibility;
+  std::unordered_set<MarkGroupID> m_groupsVisibility;
   MarksIDGroups m_groups;
 
   UserMarksRenderCollection m_marks;
diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp
index 5dc718795c..c1a4f0157a 100644
--- a/drape_frontend/user_mark_shapes.cpp
+++ b/drape_frontend/user_mark_shapes.cpp
@@ -85,12 +85,12 @@ struct UserPointVertex : gpu::BaseVertex
 } // namespace
 
 void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                    MarkIdCollection const & marksId, UserMarksRenderCollection & renderParams,
+                    IDCollection const & marksId, UserMarksRenderCollection & renderParams,
                     dp::Batcher & batcher)
 {
   float const vs = static_cast<float>(df::VisualParams::Instance().GetVisualScale());
   using UPV = UserPointVertex;
-  uint32_t const vertexCount = static_cast<uint32_t>(marksId.size()) * dp::Batcher::VertexPerQuad;
+  size_t const vertexCount = marksId.size() * dp::Batcher::VertexPerQuad;
   buffer_vector<UPV, 128> buffer;
 
   dp::TextureManager::SymbolRegion region;
@@ -131,8 +131,7 @@ void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> texture
       m2::PointD const pt = MapShape::ConvertToLocal(renderInfo.m_pivot, tileCenter,
                                                      kShapeCoordScalar);
       glsl::vec3 const pos = glsl::vec3(glsl::ToVec2(pt), renderInfo.m_depth);
-      bool const runAnim = renderInfo.m_runCreationAnim;
-      renderInfo.m_runCreationAnim = false;
+      bool const runAnim = renderInfo.m_runCreationAnim && renderInfo.m_justCreated;
 
       glsl::vec2 left, right, up, down;
       AlignHorizontal(pxSize.x * 0.5f, anchor, left, right);
@@ -177,6 +176,8 @@ void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> texture
       TextShape(renderInfo.m_pivot, params, tileKey, renderInfo.m_hasSymbolPriority /* hasPOI */,
                 symbolSize, renderInfo.m_anchor, 0 /* textIndex */).Draw(&batcher, textures);
     }
+
+    renderInfo.m_justCreated = false;
   }
 
   if (!buffer.empty())
@@ -194,7 +195,7 @@ void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> texture
 }
 
 void CacheUserLines(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                    LineIdCollection const & linesId, UserLinesRenderCollection & renderParams,
+                    IDCollection const & linesId, UserLinesRenderCollection & renderParams,
                     dp::Batcher & batcher)
 {
   float const vs = static_cast<float>(df::VisualParams::Instance().GetVisualScale());
diff --git a/drape_frontend/user_mark_shapes.hpp b/drape_frontend/user_mark_shapes.hpp
index f1721a88a9..54803b0ca5 100644
--- a/drape_frontend/user_mark_shapes.hpp
+++ b/drape_frontend/user_mark_shapes.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-#include "tile_key.hpp"
+#include "drape_frontend/tile_key.hpp"
+#include "drape_frontend/user_marks_provider.hpp"
 
 #include "drape/batcher.hpp"
 #include "drape/texture_manager.hpp"
@@ -26,6 +27,7 @@ struct UserMarkRenderParams
   float m_depth = 0.0;
   dp::GLState::DepthLayer m_depthLayer = dp::GLState::UserMarkLayer;
   bool m_runCreationAnim = false;
+  bool m_justCreated = false;
   bool m_isVisible = true;
   FeatureID m_featureId;
 };
@@ -52,17 +54,8 @@ struct UserLineRenderParams
   m2::SharedSpline m_spline;
 };
 
-using UserMarksRenderCollection = std::unordered_map<uint32_t, drape_ptr<UserMarkRenderParams>>;
-using UserLinesRenderCollection = std::unordered_map<uint32_t, drape_ptr<UserLineRenderParams>>;
-
-using MarkIdCollection = std::vector<uint32_t>;
-using LineIdCollection = std::vector<uint32_t>;
-
-struct IDCollection
-{
-  MarkIdCollection m_marksID;
-  LineIdCollection m_linesID;
-};
+using UserMarksRenderCollection = std::unordered_map<MarkID, drape_ptr<UserMarkRenderParams>>;
+using UserLinesRenderCollection = std::unordered_map<MarkID, drape_ptr<UserLineRenderParams>>;
 
 struct UserMarkRenderData
 {
@@ -80,10 +73,10 @@ struct UserMarkRenderData
 using TUserMarksRenderData = std::vector<UserMarkRenderData>;
 
 void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                    MarkIdCollection const & marksId, UserMarksRenderCollection & renderParams,
+                    IDCollection const & marksId, UserMarksRenderCollection & renderParams,
                     dp::Batcher & batcher);
 
 void CacheUserLines(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                    LineIdCollection const & linesId, UserLinesRenderCollection & renderParams,
+                    IDCollection const & linesId, UserLinesRenderCollection & renderParams,
                     dp::Batcher & batcher);
 }  // namespace df
diff --git a/drape_frontend/user_marks_provider.cpp b/drape_frontend/user_marks_provider.cpp
index f834358317..81d9cd48bb 100644
--- a/drape_frontend/user_marks_provider.cpp
+++ b/drape_frontend/user_marks_provider.cpp
@@ -2,10 +2,10 @@
 
 namespace
 {
-uint32_t GetNextUserMarkId()
+df::MarkID GetNextUserMarkId()
 {
   static uint32_t nextMarkId = 0;
-  return ++nextMarkId;
+  return static_cast<df::MarkID>(++nextMarkId);
 }
 }  // namespace
 
diff --git a/drape_frontend/user_marks_provider.hpp b/drape_frontend/user_marks_provider.hpp
index 6f4105f10e..34cf91c66f 100644
--- a/drape_frontend/user_marks_provider.hpp
+++ b/drape_frontend/user_marks_provider.hpp
@@ -15,6 +15,27 @@
 
 namespace df
 {
+using MarkID = uint32_t;
+using IDCollection = std::vector<MarkID>;
+
+using MarkGroupID = size_t;
+
+struct MarkIDCollection
+{
+  IDCollection m_marksID;
+  IDCollection m_linesID;
+
+  bool IsEmpty()
+  {
+    return m_marksID.empty() && m_linesID.empty();
+  }
+
+  void Clear()
+  {
+    m_marksID.clear();
+    m_linesID.clear();
+  }
+};
 
 class UserPointMark
 {
@@ -25,7 +46,7 @@ public:
   virtual bool IsDirty() const = 0;
   virtual void AcceptChanges() const = 0;
 
-  uint32_t GetId() const { return m_id; }
+  MarkID GetId() const { return m_id; }
 
   virtual m2::PointD const & GetPivot() const = 0;
   virtual m2::PointD GetPixelOffset() const = 0;
@@ -33,7 +54,6 @@ public:
   virtual dp::Anchor GetAnchor() const = 0;
   virtual float GetDepth() const = 0;
   virtual dp::GLState::DepthLayer GetDepthLayer() const = 0;
-  virtual bool HasCreationAnimation() const = 0;
   virtual bool IsVisible() const = 0;
   virtual drape_ptr<dp::TitleDecl> GetTitleDecl() const = 0;
   virtual uint16_t GetPriority() const = 0;
@@ -41,9 +61,10 @@ public:
   virtual bool HasTitlePriority() const = 0;
   virtual int GetMinZoom() const = 0;
   virtual FeatureID GetFeatureID() const = 0;
+  virtual bool RunCreationAnim() const = 0;
 
 private:
-  uint32_t m_id;
+  MarkID m_id;
 };
 
 class UserLineMark
@@ -55,7 +76,7 @@ public:
   virtual bool IsDirty() const = 0;
   virtual void AcceptChanges() const = 0;
 
-  virtual uint32_t GetId() const { return m_id; }
+  virtual MarkID GetId() const { return m_id; }
 
   virtual int GetMinZoom() const = 0;
   virtual dp::GLState::DepthLayer GetDepthLayer() const = 0;
@@ -66,7 +87,7 @@ public:
   virtual std::vector<m2::PointD> const & GetPoints() const = 0;
 
 private:
-  uint32_t m_id;
+  MarkID m_id;
 };
 
 class UserMarksProvider
@@ -76,7 +97,7 @@ public:
   virtual ~UserMarksProvider() {}
 
   virtual bool IsDirty() const = 0;
-  virtual void AcceptChanges(std::vector<uint32_t> & removedMarks) = 0;
+  virtual void AcceptChanges(MarkIDCollection & createdMarks, MarkIDCollection & removedMarks) = 0;
 
   virtual bool IsDrawable() const = 0;
 
diff --git a/map/api_mark_point.cpp b/map/api_mark_point.cpp
index 9a07280db7..02d11589c0 100644
--- a/map/api_mark_point.cpp
+++ b/map/api_mark_point.cpp
@@ -55,3 +55,21 @@ m2::PointD ApiMarkPoint::GetPixelOffset() const
 {
   return m_style.empty() ? m2::PointD(0.0, 0.0) : m2::PointD(0.0, 3.0);
 }
+
+void ApiMarkPoint::SetName(string const & name)
+{
+  SetDirty();
+  m_name = name;
+}
+
+void ApiMarkPoint::SetApiID(string const & id)
+{
+  SetDirty();
+  m_id = id;
+}
+
+void ApiMarkPoint::SetStyle(string const & style)
+{
+  SetDirty();
+  m_style = style;
+}
diff --git a/map/api_mark_point.hpp b/map/api_mark_point.hpp
index 12870c2ef9..c0b8868bc1 100644
--- a/map/api_mark_point.hpp
+++ b/map/api_mark_point.hpp
@@ -30,12 +30,12 @@ public:
   m2::PointD GetPixelOffset() const override;
 
   string const & GetName() const { return m_name; }
-  void SetName(string const & name) { m_name = name; }
+  void SetName(string const & name);
 
-  string const & GetID() const { return m_id; }
-  void SetID(string const & id) { m_id = id; }
+  string const & GetApiID() const { return m_id; }
+  void SetApiID(string const & id);
 
-  void SetStyle(string const & style) { m_style = style; }
+  void SetStyle(string const & style);
   string const & GetStyle() const { return m_style; }
 
 private:
diff --git a/map/bookmark.cpp b/map/bookmark.cpp
index 01f284690b..681c8a12c2 100644
--- a/map/bookmark.cpp
+++ b/map/bookmark.cpp
@@ -30,14 +30,12 @@
 
 Bookmark::Bookmark(m2::PointD const & ptOrg, UserMarkContainer * container)
   : TBase(ptOrg, container)
-  , m_hasCreationAnimation(false)
 {
 }
 
 Bookmark::Bookmark(BookmarkData const & data, m2::PointD const & ptOrg, UserMarkContainer * container)
   : TBase(ptOrg, container)
   , m_data(data)
-  , m_hasCreationAnimation(false)
 {
 }
 
@@ -62,23 +60,16 @@ std::string Bookmark::GetSymbolName() const
   return GetType();
 }
 
+bool Bookmark::RunCreationAnim() const
+{
+  return true;
+}
+
 UserMark::Type Bookmark::GetMarkType() const
 {
   return UserMark::Type::BOOKMARK;
 }
 
-bool Bookmark::HasCreationAnimation() const
-{
-  bool const result = m_hasCreationAnimation;
-  m_hasCreationAnimation = false;
-  return result;
-}
-
-void Bookmark::SetCreationAnimationShown(bool shown)
-{
-  m_hasCreationAnimation = !shown;
-}
-
 std::string const & Bookmark::GetName() const
 {
   return m_data.GetName();
diff --git a/map/bookmark.hpp b/map/bookmark.hpp
index 5c8182289f..888544c5f3 100644
--- a/map/bookmark.hpp
+++ b/map/bookmark.hpp
@@ -83,10 +83,9 @@ public:
 
   dp::Anchor GetAnchor() const override;
   std::string GetSymbolName() const override;
+  bool RunCreationAnim() const override;
 
   Type GetMarkType() const override;
-  bool HasCreationAnimation() const override;
-  void SetCreationAnimationShown(bool shown);
 
   std::string const & GetName() const;
   void SetName(std::string const & name);
@@ -107,7 +106,6 @@ public:
 
 private:
   BookmarkData m_data;
-  mutable bool m_hasCreationAnimation;
 };
 
 class BookmarkCategory : public UserMarkContainer
diff --git a/map/bookmark_manager.cpp b/map/bookmark_manager.cpp
index e67ea94310..06dd3d84c9 100644
--- a/map/bookmark_manager.cpp
+++ b/map/bookmark_manager.cpp
@@ -96,7 +96,6 @@ size_t BookmarkManager::AddBookmark(size_t categoryIndex, m2::PointD const & ptO
 
   Bookmark * bookmark = static_cast<Bookmark *>(cat.CreateUserMark(ptOrg));
   bookmark->SetData(bm);
-  bookmark->SetCreationAnimationShown(false);
   cat.SetIsVisible(true);
   cat.SaveToKMLFile();
   cat.NotifyChanges();
diff --git a/map/framework.cpp b/map/framework.cpp
index ad740f5179..ac2c0cd171 100644
--- a/map/framework.cpp
+++ b/map/framework.cpp
@@ -981,7 +981,7 @@ void Framework::FillApiMarkInfo(ApiMarkPoint const & api, place_page::Info & inf
   string const & name = api.GetName();
   if (!name.empty())
     info.SetCustomName(name);
-  info.SetApiId(api.GetID());
+  info.SetApiId(api.GetApiID());
   info.SetApiUrl(GenerateApiBackUrl(api));
 }
 
@@ -2651,8 +2651,8 @@ string Framework::GenerateApiBackUrl(ApiMarkPoint const & point) const
     res += "pin?ll=" + strings::to_string(ll.lat) + "," + strings::to_string(ll.lon);
     if (!point.GetName().empty())
       res += "&n=" + UrlEncode(point.GetName());
-    if (!point.GetID().empty())
-      res += "&id=" + UrlEncode(point.GetID());
+    if (!point.GetApiID().empty())
+      res += "&id=" + UrlEncode(point.GetApiID());
   }
   return res;
 }
diff --git a/map/map_tests/mwm_url_tests.cpp b/map/map_tests/mwm_url_tests.cpp
index 8823f7583d..d453724067 100644
--- a/map/map_tests/mwm_url_tests.cpp
+++ b/map/map_tests/mwm_url_tests.cpp
@@ -76,7 +76,7 @@ namespace
 
     bool TestID(int index, string const & id) const
     {
-      return GetMark(index)->GetID() == id;
+      return GetMark(index)->GetApiID() == id;
     }
 
     bool TestRouteType(string const & type) const { return m_api.GetRoutingType() == type; }
diff --git a/map/mwm_url.cpp b/map/mwm_url.cpp
index 3e731fd46f..6c12ca29e2 100644
--- a/map/mwm_url.cpp
+++ b/map/mwm_url.cpp
@@ -198,7 +198,7 @@ ParsedMapApi::ParsingResult ParsedMapApi::Parse(Uri const & uri)
         m2::PointD glPoint(MercatorBounds::FromLatLon(p.m_lat, p.m_lon));
         ApiMarkPoint * mark = static_cast<ApiMarkPoint *>(guard.m_controller.CreateUserMark(glPoint));
         mark->SetName(p.m_name);
-        mark->SetID(p.m_id);
+        mark->SetApiID(p.m_id);
         mark->SetStyle(style::GetSupportedStyle(p.m_style, p.m_name, ""));
       }
 
diff --git a/map/user_mark.cpp b/map/user_mark.cpp
index ad5b75c121..fb523ee075 100644
--- a/map/user_mark.cpp
+++ b/map/user_mark.cpp
@@ -37,11 +37,6 @@ dp::GLState::DepthLayer UserMark::GetDepthLayer() const
   return dp::GLState::UserMarkLayer;
 }
 
-bool UserMark::HasCreationAnimation() const
-{
-  return false;
-}
-
 UserMarkContainer const * UserMark::GetContainer() const
 {
   ASSERT(m_container != nullptr, ());
diff --git a/map/user_mark.hpp b/map/user_mark.hpp
index ca5a8549e9..9fb942a59e 100644
--- a/map/user_mark.hpp
+++ b/map/user_mark.hpp
@@ -46,13 +46,13 @@ public:
   dp::Anchor GetAnchor() const override;
   float GetDepth() const override;
   dp::GLState::DepthLayer GetDepthLayer() const override;
-  bool HasCreationAnimation() const override;
   drape_ptr<dp::TitleDecl> GetTitleDecl() const override { return nullptr; }
   uint16_t GetPriority() const override { return kDefaultUserMarkProirity; }
   bool HasSymbolPriority() const override { return false; }
   bool HasTitlePriority() const override { return false; }
   int GetMinZoom() const override { return 1; }
   FeatureID GetFeatureID() const override { return FeatureID(); }
+  bool RunCreationAnim() const override { return false; }
 
   UserMarkContainer const * GetContainer() const;
   ms::LatLon GetLatLon() const;
diff --git a/map/user_mark_container.cpp b/map/user_mark_container.cpp
index c258857358..c75ad47dbe 100644
--- a/map/user_mark_container.cpp
+++ b/map/user_mark_container.cpp
@@ -47,9 +47,9 @@ public:
 size_t const VisibleFlag = 0;
 size_t const DrawableFlag = 1;
 
-size_t GenerateLayerId(UserMarkContainer const * cont)
+df::MarkGroupID GenerateMarkGroupId(UserMarkContainer const * cont)
 {
-  return reinterpret_cast<size_t>(cont);
+  return reinterpret_cast<df::MarkGroupID>(cont);
 }
 
 } // namespace
@@ -114,25 +114,27 @@ MyPositionMarkPoint * UserMarkContainer::UserMarkForMyPostion()
 
 void UserMarkContainer::NotifyChanges()
 {
+  if (!IsDirty())
+    return;
+
   ref_ptr<df::DrapeEngine> engine = m_framework.GetDrapeEngine();
   if (engine == nullptr)
     return;
 
-  size_t const layerId = GenerateLayerId(this);
-  engine->ChangeVisibilityUserMarksLayer(layerId, IsVisible() && IsDrawable());
-
-  if (!IsDirty())
-    return;
+  df::MarkGroupID const groupId = GenerateMarkGroupId(this);
+  engine->ChangeVisibilityUserMarksGroup(groupId, IsVisible() && IsDrawable());
 
   if (GetUserPointCount() == 0 && GetUserLineCount() == 0)
   {
-    engine->UpdateUserMarksLayer(layerId, this);
-    engine->ClearUserMarksLayer(layerId);
+    engine->UpdateUserMarksGroup(groupId, this);
+    engine->ClearUserMarksGroup(groupId);
   }
   else if (IsVisible() && IsDrawable())
   {
-    engine->UpdateUserMarksLayer(layerId, this);
+    engine->UpdateUserMarksGroup(groupId, this);
   }
+
+  engine->InvalidateUserMarks();
 }
 
 size_t UserMarkContainer::GetUserPointCount() const
@@ -177,6 +179,7 @@ UserMark * UserMarkContainer::CreateUserMark(m2::PointD const & ptOrg)
   // Push front an user mark.
   SetDirty();
   m_userMarks.push_front(unique_ptr<UserMark>(AllocateUserMark(ptOrg)));
+  m_createdMarks.m_marksID.push_back(m_userMarks.front()->GetId());
   return m_userMarks.front().get();
 }
 
@@ -213,13 +216,19 @@ void UserMarkContainer::Clear(size_t skipCount/* = 0*/)
 void UserMarkContainer::SetIsDrawable(bool isDrawable)
 {
   if (IsDrawable() != isDrawable)
+  {
+    SetDirty();
     m_flags[DrawableFlag] = isDrawable;
+  }
 }
 
 void UserMarkContainer::SetIsVisible(bool isVisible)
 {
   if (IsVisible() != isVisible)
+  {
+    SetDirty();
     m_flags[VisibleFlag] = isVisible;
+  }
 }
 
 void UserMarkContainer::Update()
@@ -243,7 +252,7 @@ void UserMarkContainer::DeleteUserMark(size_t index)
   ASSERT_LESS(index, m_userMarks.size(), ());
   if (index < m_userMarks.size())
   {
-    m_removedMarks.push_back(m_userMarks[index]->GetId());
+    m_removedMarks.m_marksID.push_back(m_userMarks[index]->GetId());
     m_userMarks.erase(m_userMarks.begin() + index);
   }
   else
@@ -252,10 +261,15 @@ void UserMarkContainer::DeleteUserMark(size_t index)
   }
 }
 
-void UserMarkContainer::AcceptChanges(std::vector<uint32_t> & removedMarks)
+void UserMarkContainer::AcceptChanges(df::MarkIDCollection & createdMarks,
+                                      df::MarkIDCollection & removedMarks)
 {
-  removedMarks.swap(m_removedMarks);
-  m_removedMarks.clear();
+  std::swap(m_createdMarks, createdMarks);
+  m_createdMarks.Clear();
+
+  std::swap(m_removedMarks, removedMarks);
+  m_removedMarks.Clear();
+
   m_isDirty = false;
 }
 
diff --git a/map/user_mark_container.hpp b/map/user_mark_container.hpp
index 21de4f0dc9..6d5c484753 100644
--- a/map/user_mark_container.hpp
+++ b/map/user_mark_container.hpp
@@ -72,7 +72,8 @@ public:
   bool IsDirty() const override;
 
   // Discard isDirty flag, return id collection of removed marks since previous method call.
-  void AcceptChanges(std::vector<uint32_t> & removedMarks) override;
+  void AcceptChanges(df::MarkIDCollection & createdMarks,
+                     df::MarkIDCollection & removedMarks) override;
 
   float GetPointDepth() const;
 
@@ -104,7 +105,8 @@ private:
   double m_layerDepth;
   TUserMarksList m_userMarks;
   UserMarkType m_type;
-  std::vector<uint32_t> m_removedMarks;
+  df::MarkIDCollection m_createdMarks;
+  df::MarkIDCollection m_removedMarks;
   bool m_isDirty = false;
 };