Slic3r::UndoRedo::StackImpl Class Reference

Collaboration diagram for Slic3r::UndoRedo::StackImpl:

Public Member Functions
	StackImpl ()
void	clear ()
bool	empty () const
void	set_memory_limit (size_t memsize)
size_t	get_memory_limit () const
size_t	memsize () const
void	take_snapshot (const std::string &snapshot_name, const Slic3r::Model &model, const Slic3r::GUI::Selection &selection, const Slic3r::GUI::GLGizmosManager &gizmos, const SnapshotData &snapshot_data)
void	reduce_noisy_snapshots (const std::string &new_name)
void	load_snapshot (size_t timestamp, Slic3r::Model &model, Slic3r::GUI::GLGizmosManager &gizmos)
bool	has_undo_snapshot () const
bool	has_undo_snapshot (size_t time_to_load) const
bool	has_redo_snapshot () const
bool	undo (Slic3r::Model &model, const Slic3r::GUI::Selection &selection, Slic3r::GUI::GLGizmosManager &gizmos, const SnapshotData &snapshot_data, size_t jump_to_time)
bool	redo (Slic3r::Model &model, Slic3r::GUI::GLGizmosManager &gizmos, size_t jump_to_time)
void	release_least_recently_used ()
const std::vector< Snapshot > &	snapshots () const
const Snapshot &	snapshot (size_t time) const
size_t	active_snapshot_time () const
bool	temp_snapshot_active () const
void	mark_current_as_saved ()
bool	project_modified () const
const Selection &	selection_deserialized () const
template<typename T >
ObjectID	save_mutable_object (const T &object)
template<typename T >
ObjectID	save_immutable_object (std::shared_ptr< const T > &object, bool optional)
template<typename T >
T *	load_mutable_object (const Slic3r::ObjectID id)
template<typename T >
std::shared_ptr< const T >	load_immutable_object (const Slic3r::ObjectID id, bool optional)
template<typename T >
void	load_mutable_object (const Slic3r::ObjectID id, T &target)
bool	valid () const

Private Member Functions
template<typename T >
ObjectID	immutable_object_id (const std::shared_ptr< const T > &ptr)
ObjectID	immutable_object_id_impl (const void *ptr)
void	collect_garbage ()
std::vector< Snapshot >::iterator	release_snapshots (std::vector< Snapshot >::iterator begin, std::vector< Snapshot >::iterator end)

Private Attributes
size_t	m_memory_limit
std::map< ObjectID, std::unique_ptr< ObjectHistoryBase > >	m_objects
std::map< const void *, ObjectID >	m_shared_ptr_to_object_id
std::vector< Snapshot >	m_snapshots
size_t	m_active_snapshot_time
size_t	m_saved_snapshot_time { size_t(-1) }
size_t	m_current_time
Selection	m_selection

Detailed Description

Constructor & Destructor Documentation

StackImpl()

Slic3r::UndoRedo::StackImpl::StackImpl ( )

inline

: m_memory_limit(std::min(Slic3r::total_physical_memory() / 10, size_t(1 * 16384 * 65536 / UNDO_REDO_DEBUG_LOW_MEM_FACTOR))), m_active_snapshot_time(0), m_current_time(0) {}

Member Function Documentation

active_snapshot_time()

size_t Slic3r::UndoRedo::StackImpl::active_snapshot_time ( ) const

inline

{ return m_active_snapshot_time; }

References m_active_snapshot_time.

clear()

void Slic3r::UndoRedo::StackImpl::clear ( )

inline

               {
    m_objects.clear();
    m_shared_ptr_to_object_id.clear();
    m_snapshots.clear();
    m_active_snapshot_time = 0;
    m_current_time = 0;
    m_saved_snapshot_time = size_t(-1);
    m_selection.clear();
  }

References Slic3r::UndoRedo::Selection::clear(), m_active_snapshot_time, m_current_time, m_objects, m_saved_snapshot_time, m_selection, m_shared_ptr_to_object_id, and m_snapshots.

Here is the call graph for this function:

collect_garbage()

void Slic3r::UndoRedo::StackImpl::collect_garbage ( )

private

{
  // Purge objects with empty histories.
  for (auto it = m_objects.begin(); it != m_objects.end();) {
    if (it->second->empty()) {
      if (it->second->immutable_object_ptr() != nullptr)
        // Release the immutable object from the ptr to ObjectID map.
        m_shared_ptr_to_object_id.erase(it->second->immutable_object_ptr());
      it = m_objects.erase(it);
    } else
      ++ it;
  }
}

References m_objects, and m_shared_ptr_to_object_id.

Referenced by take_snapshot().

Here is the caller graph for this function:

empty()

bool Slic3r::UndoRedo::StackImpl::empty ( ) const

inline

                     {
    assert(m_objects.empty() == m_snapshots.empty());
    assert(! m_objects.empty() || (m_current_time == 0 && m_active_snapshot_time == 0));
    return m_snapshots.empty();
  }

References m_active_snapshot_time, m_current_time, m_objects, and m_snapshots.

get_memory_limit()

size_t Slic3r::UndoRedo::StackImpl::get_memory_limit ( ) const

inline

{ return m_memory_limit; }

References m_memory_limit.

has_redo_snapshot()

bool Slic3r::UndoRedo::StackImpl::has_redo_snapshot

(

)

const

{
  assert(this->valid());
  auto it = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(m_active_snapshot_time));
  return ++ it != m_snapshots.end();
}

References m_active_snapshot_time, m_snapshots, and valid().

Here is the call graph for this function:

has_undo_snapshot() [1/2]

bool Slic3r::UndoRedo::StackImpl::has_undo_snapshot

(

)

const

{ 
  assert(this->valid());
  auto it = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(m_active_snapshot_time));
  return -- it != m_snapshots.begin();
}

References m_active_snapshot_time, m_snapshots, and valid().

Here is the call graph for this function:

has_undo_snapshot() [2/2]

bool Slic3r::UndoRedo::StackImpl::has_undo_snapshot

(

size_t

time_to_load

)

const

{
  return time_to_load < m_active_snapshot_time && std::binary_search(m_snapshots.begin(), m_snapshots.end(), Snapshot(time_to_load));
}

References m_active_snapshot_time, and m_snapshots.

immutable_object_id()

template<typename T >

ObjectID Slic3r::UndoRedo::StackImpl::immutable_object_id ( const std::shared_ptr< const T > &  ptr )

inlineprivate

                                                                                         { 
    return this->immutable_object_id_impl((const void*)ptr.get());
  }

References immutable_object_id_impl().

Referenced by save_immutable_object().

Here is the call graph for this function:

Here is the caller graph for this function:

immutable_object_id_impl()

ObjectID Slic3r::UndoRedo::StackImpl::immutable_object_id_impl ( const void *  ptr )

inlineprivate

                                                                  {
    auto it = m_shared_ptr_to_object_id.find(ptr);
    if (it == m_shared_ptr_to_object_id.end()) {
      // Allocate a new temporary ObjectID for this shared pointer.
      ObjectBase object_with_id;
      it = m_shared_ptr_to_object_id.insert(it, std::make_pair(ptr, object_with_id.id()));
    }
    return it->second;
  }

References Slic3r::ObjectBase::id(), and m_shared_ptr_to_object_id.

Referenced by immutable_object_id().

Here is the call graph for this function:

Here is the caller graph for this function:

load_immutable_object()

template<typename T >

std::shared_ptr< const T > Slic3r::UndoRedo::StackImpl::load_immutable_object	(	const Slic3r::ObjectID	id,
		bool	optional
	)

{
  // First find a history stack for the ObjectID of this object instance.
  auto it_object_history = m_objects.find(id);
  assert(optional || it_object_history != m_objects.end());
  if (it_object_history == m_objects.end())
    return std::shared_ptr<const T>();
  auto *object_history = static_cast<ImmutableObjectHistory<T>*>(it_object_history->second.get());
  assert(object_history->has_snapshot(m_active_snapshot_time));
  object_history->restore_optional();
  return object_history->shared_ptr(*this);
}

References m_active_snapshot_time, and m_objects.

Referenced by cereal::load(), and cereal::load_optional().

Here is the caller graph for this function:

load_mutable_object() [1/2]

template<typename T >

T * Slic3r::UndoRedo::StackImpl::load_mutable_object

(

const Slic3r::ObjectID

id

)

{
  T *target = new T();
  this->load_mutable_object<T>(id, *target);
  return target;
}

Referenced by cereal::load(), cereal::load(), and cereal::load_by_value().

Here is the caller graph for this function:

load_mutable_object() [2/2]

template<typename T >

void Slic3r::UndoRedo::StackImpl::load_mutable_object	(	const Slic3r::ObjectID	id,
		T &	target
	)

{
  // First find a history stack for the ObjectID of this object instance.
  auto it_object_history = m_objects.find(id);
  assert(it_object_history != m_objects.end());
  auto *object_history = static_cast<const MutableObjectHistory<T>*>(it_object_history->second.get());
  // Then get the data associated with the object history and m_active_snapshot_time.
  std::istringstream iss(object_history->load(m_active_snapshot_time));
  Slic3r::UndoRedo::InputArchive archive(*this, iss);
  target.m_id = id;
  archive(target);
}

References m_active_snapshot_time, and m_objects.

load_snapshot()

void Slic3r::UndoRedo::StackImpl::load_snapshot	(	size_t	timestamp,
		Slic3r::Model &	model,
		Slic3r::GUI::GLGizmosManager &	gizmos
	)

{
  // Find the snapshot by time. It must exist.
  const auto it_snapshot = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(timestamp));
  if (it_snapshot == m_snapshots.end() || it_snapshot->timestamp != timestamp)
    throw Slic3r::RuntimeError((boost::format("Snapshot with timestamp %1% does not exist") % timestamp).str());
 
  m_active_snapshot_time = timestamp;
  model.clear_objects();
  model.clear_materials();
  this->load_mutable_object<Slic3r::Model>(ObjectID(it_snapshot->model_id), model);
  model.update_links_bottom_up_recursive();
  m_selection.volumes_and_instances.clear();
  this->load_mutable_object<Selection>(m_selection.id(), m_selection);
    //gizmos.reset_all_states(); FIXME: is this really necessary? It is quite unpleasant for the gizmo undo/redo substack
    this->load_mutable_object<Slic3r::GUI::GLGizmosManager>(gizmos.id(), gizmos);
    // Sort the volumes so that we may use binary search.
  std::sort(m_selection.volumes_and_instances.begin(), m_selection.volumes_and_instances.end());
  m_active_snapshot_time = timestamp;
  assert(this->valid());
}

References Slic3r::Model::clear_materials(), Slic3r::Model::clear_objects(), Slic3r::ObjectBase::id(), m_active_snapshot_time, m_selection, m_snapshots, Slic3r::Model::update_links_bottom_up_recursive(), valid(), and Slic3r::UndoRedo::Selection::volumes_and_instances.

Referenced by redo(), and undo().

Here is the call graph for this function:

Here is the caller graph for this function:

mark_current_as_saved()

void Slic3r::UndoRedo::StackImpl::mark_current_as_saved ( )

inline

{ m_saved_snapshot_time = m_active_snapshot_time; }

References m_active_snapshot_time, and m_saved_snapshot_time.

memsize()

size_t Slic3r::UndoRedo::StackImpl::memsize ( ) const

inline

                         {
    size_t memsize = 0;
    for (const auto &object : m_objects)
      memsize += object.second->memsize();
    return memsize;
  }

References m_objects, and memsize().

Referenced by memsize(), release_least_recently_used(), and set_memory_limit().

Here is the call graph for this function:

Here is the caller graph for this function:

project_modified()

bool Slic3r::UndoRedo::StackImpl::project_modified

(

)

const

{
  assert(! m_snapshots.empty());
 
  if (m_saved_snapshot_time == size_t(-1))
    // Don't know anything about the project state.
    return true;
  if (m_saved_snapshot_time == m_active_snapshot_time)
    // Just saved at this step.
    return false;
 
  assert(m_saved_snapshot_time >= m_snapshots.front().timestamp && m_saved_snapshot_time <= m_snapshots.back().timestamp);
 
  auto it_saved = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(m_saved_snapshot_time));
  assert(it_saved != m_snapshots.end() && it_saved->timestamp == m_saved_snapshot_time);
 
#ifndef NDEBUG
  // Verify that there is a snapshot with "current time".
  auto it_current = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(m_active_snapshot_time));
  assert(it_current != m_snapshots.end() && it_current->timestamp == m_active_snapshot_time);
#endif // NDEBUG
 
  if (m_saved_snapshot_time < m_active_snapshot_time) {
    // Search upwards. Ignore state of the "active" snapshot.
    for (auto it = it_saved; it->timestamp < m_active_snapshot_time; ++ it)
      if (snapshot_modifies_project(*it))
        return true;
  } else {
    // Search downwards. Ignore state of the "saved" snapshot.
    assert(m_saved_snapshot_time > m_active_snapshot_time);
    for (auto it = it_saved - 1; it->timestamp >= m_active_snapshot_time; -- it)
      if (snapshot_modifies_project(*it))
        return true;
  }
 
  return false;
}

References m_active_snapshot_time, m_saved_snapshot_time, m_snapshots, and Slic3r::UndoRedo::snapshot_modifies_project().

Here is the call graph for this function:

redo()

bool Slic3r::UndoRedo::StackImpl::redo	(	Slic3r::Model &	model,
		Slic3r::GUI::GLGizmosManager &	gizmos,
		size_t	jump_to_time
	)

{
  assert(this->valid());
  if (time_to_load == SIZE_MAX) {
    auto it_current = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(m_active_snapshot_time));
    if (++ it_current == m_snapshots.end())
      return false;
    time_to_load = it_current->timestamp;
  }
  assert(time_to_load > m_active_snapshot_time);
  assert(std::binary_search(m_snapshots.begin(), m_snapshots.end(), Snapshot(time_to_load)));
    this->load_snapshot(time_to_load, model, gizmos);
#ifdef SLIC3R_UNDOREDO_DEBUG
  std::cout << "After redo" << std::endl;
  this->print();
#endif /* SLIC3R_UNDOREDO_DEBUG */
  return true;
}

References load_snapshot(), m_active_snapshot_time, m_snapshots, SIZE_MAX, and valid().

Here is the call graph for this function:

reduce_noisy_snapshots()

void Slic3r::UndoRedo::StackImpl::reduce_noisy_snapshots

(

const std::string &

new_name

)

{
  // Preceding snapshot must be a "leave gizmo" snapshot.
  assert(! m_snapshots.empty() && m_snapshots.back().is_topmost() && m_snapshots.back().timestamp == m_active_snapshot_time);
  auto it_last = m_snapshots.end();
  -- it_last; -- it_last;
  assert(it_last != m_snapshots.begin() && (it_last->snapshot_data.snapshot_type == SnapshotType::LeavingGizmoNoAction || it_last->snapshot_data.snapshot_type == SnapshotType::LeavingGizmoWithAction));
  if (it_last->snapshot_data.snapshot_type == SnapshotType::LeavingGizmoWithAction) {
    for (-- it_last; it_last->snapshot_data.snapshot_type != SnapshotType::EnteringGizmo; -- it_last) {
      if (it_last->snapshot_data.snapshot_type == SnapshotType::GizmoAction) {
                it_last->name = new_name;
                auto it = it_last;
        for (-- it; it->snapshot_data.snapshot_type == SnapshotType::GizmoAction; -- it) ;
        if (++ it < it_last) {
          // Drop (it, it_last>
          for (auto &kvp : m_objects)
            // Drop products of <it + 1, it_last + 1>
            kvp.second->release_between_timestamps(it->timestamp, (it_last + 1)->timestamp);
          it_last = this->release_snapshots(it + 1, it_last + 1);
        }
      }
      assert(it_last != m_snapshots.begin());
    }
  }
}

References Slic3r::UndoRedo::EnteringGizmo, Slic3r::UndoRedo::GizmoAction, Slic3r::UndoRedo::LeavingGizmoNoAction, Slic3r::UndoRedo::LeavingGizmoWithAction, m_active_snapshot_time, m_objects, m_snapshots, and release_snapshots().

Here is the call graph for this function:

release_least_recently_used()

void Slic3r::UndoRedo::StackImpl::release_least_recently_used

(

)

{
  assert(this->valid());
  size_t current_memsize = this->memsize();
#ifdef SLIC3R_UNDOREDO_DEBUG
  bool released = false;
#endif
  // First try to release the optional immutable data (for example the convex hulls),
  // or the shared vertices of triangle meshes.
  for (auto it = m_objects.begin(); current_memsize > m_memory_limit && it != m_objects.end();) {
    const void *ptr = it->second->immutable_object_ptr();
    size_t mem_released = it->second->release_optional();
    if (it->second->empty()) {
      if (ptr != nullptr)
        // Release the immutable object from the ptr to ObjectID map.
        m_shared_ptr_to_object_id.erase(ptr);
      mem_released += it->second->memsize();
      it = m_objects.erase(it);
    } else
      ++ it;
    assert(current_memsize >= mem_released);
    if (current_memsize >= mem_released)
      current_memsize -= mem_released;
    else
      current_memsize = 0;
  }
  while (current_memsize > m_memory_limit && m_snapshots.size() >= 3) {
    // From which side to remove a snapshot?
    assert(m_snapshots.front().timestamp < m_active_snapshot_time);
    size_t mem_released = 0;
    if (m_snapshots[1].timestamp == m_active_snapshot_time) {
      // Remove the last snapshot.
#if 0
      for (auto it = m_objects.begin(); it != m_objects.end();) {
        mem_released += it->second->release_after_timestamp(m_snapshots.back().timestamp);
        if (it->second->empty()) {
          if (it->second->immutable_object_ptr() != nullptr)
            // Release the immutable object from the ptr to ObjectID map.
            m_shared_ptr_to_object_id.erase(it->second->immutable_object_ptr());
          mem_released += it->second->memsize();
          it = m_objects.erase(it);
        } else
          ++ it;
      }
      m_snapshots.pop_back();
      m_snapshots.back().name = topmost_snapshot_name;
#else
      // Rather don't release the last snapshot as it will be very confusing to the user
      // as of why he cannot jump to the top most state. The Undo / Redo stack maximum size
      // should be set low enough to accomodate for the top most snapshot.
      break;
#endif
    } else {
      // Remove the first snapshot.
      for (auto it = m_objects.begin(); it != m_objects.end();) {
        mem_released += it->second->release_before_timestamp(m_snapshots[1].timestamp);
        if (it->second->empty()) {
          if (it->second->immutable_object_ptr() != nullptr)
            // Release the immutable object from the ptr to ObjectID map.
            m_shared_ptr_to_object_id.erase(it->second->immutable_object_ptr());
          mem_released += it->second->memsize();
          it = m_objects.erase(it);
        } else
          ++ it;
      }
      //FIXME update the "saved" snapshot time.
      m_snapshots.erase(m_snapshots.begin());
    }
    assert(current_memsize >= mem_released);
    if (current_memsize >= mem_released)
      current_memsize -= mem_released;
    else
      current_memsize = 0;
#ifdef SLIC3R_UNDOREDO_DEBUG
    released = true;
#endif
  }
  assert(this->valid());
#ifdef SLIC3R_UNDOREDO_DEBUG
  std::cout << "After release_least_recently_used" << std::endl;
  this->print();
#endif /* SLIC3R_UNDOREDO_DEBUG */
}

References m_active_snapshot_time, m_memory_limit, m_objects, m_shared_ptr_to_object_id, m_snapshots, memsize(), Slic3r::UndoRedo::topmost_snapshot_name, and valid().

Here is the call graph for this function:

release_snapshots()

std::vector< Snapshot >::iterator Slic3r::UndoRedo::StackImpl::release_snapshots ( std::vector< Snapshot >::iterator  begin, std::vector< Snapshot >::iterator  end  )

private

{
  assert(! m_snapshots.empty());
  assert(begin <= end);
  if (m_saved_snapshot_time != size_t(-1) && m_saved_snapshot_time >= begin->timestamp && (end == m_snapshots.end() || m_saved_snapshot_time < end->timestamp)) {
    assert(m_saved_snapshot_time <= m_snapshots.back().timestamp);
    auto it_saved = std::lower_bound(begin, end, Snapshot(m_saved_snapshot_time));
    assert(it_saved != m_snapshots.end() && it_saved->timestamp == m_saved_snapshot_time);
    auto it = it_saved;
    for (; it != begin && ! snapshot_modifies_project(*it); -- it) ;
    if (it == begin && ! snapshot_modifies_project(*it)) {
      // Found a snapshot before begin, which captures the same project state.
      m_saved_snapshot_time = (-- it)->timestamp;
    } else {
      auto it = it_saved;
      for (; it != end && ! snapshot_modifies_project(*it); ++ it) ;
      if (it == end && end != m_snapshots.end())
        // Found a snapshot after end, which captures the same project state.
        m_saved_snapshot_time = (-- it)->timestamp;       
      else
        // State of the project is being lost. Indicate a "likely modified" project state until the project is saved again.
        m_saved_snapshot_time = size_t(-1);
    }
  }
  return m_snapshots.erase(begin, end);
}

References m_saved_snapshot_time, m_snapshots, and Slic3r::UndoRedo::snapshot_modifies_project().

Referenced by reduce_noisy_snapshots(), and take_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

save_immutable_object()

template<typename T >

ObjectID Slic3r::UndoRedo::StackImpl::save_immutable_object	(	std::shared_ptr< const T > &	object,
		bool	optional
	)

{
  // First allocate a temporary ObjectID for this pointer.
  ObjectID object_id = this->immutable_object_id(object);
  // and find or allocate a history stack for the ObjectID associated to this shared_ptr.
  auto it_object_history = m_objects.find(object_id);
  if (it_object_history == m_objects.end())
    it_object_history = m_objects.emplace_hint(it_object_history, object_id, std::unique_ptr<ImmutableObjectHistory<T>>(new ImmutableObjectHistory<T>(object, optional)));
  else
    assert(it_object_history->second.get()->is_optional() == optional);
  // Then save the interval.
  static_cast<ImmutableObjectHistory<T>*>(it_object_history->second.get())->save(m_active_snapshot_time, m_current_time);
  return object_id;
}

References immutable_object_id(), m_active_snapshot_time, m_current_time, m_objects, and save().

Here is the call graph for this function:

save_mutable_object()

template<typename T >

ObjectID Slic3r::UndoRedo::StackImpl::save_mutable_object

(

const T &

object

)

{
  // First find or allocate a history stack for the ObjectID of this object instance.
  auto it_object_history = m_objects.find(object.id());
  if (it_object_history == m_objects.end())
    it_object_history = m_objects.insert(it_object_history, std::make_pair(object.id(), std::unique_ptr<MutableObjectHistory<T>>(new MutableObjectHistory<T>())));
  auto *object_history = static_cast<MutableObjectHistory<T>*>(it_object_history->second.get());
  bool  needs_to_save  = true;
  {
    // If the timestamp returned is non zero, then it is considered reliable.
    // The caller is supposed to serialize the timestamp first.
    uint64_t timestamp = object.timestamp();
    if (timestamp > 0)
      needs_to_save = ! object_history->try_save_timestamp(m_active_snapshot_time, m_current_time, timestamp);
  }
  if (needs_to_save) {
    // Serialize the object into a string.
    std::ostringstream oss;
    {
      Slic3r::UndoRedo::OutputArchive archive(*this, oss);
      archive(object);
    }
    object_history->save(m_active_snapshot_time, m_current_time, oss.str());
  }
  return object.id();
}

References m_active_snapshot_time, m_current_time, m_objects, and Slic3r::UndoRedo::MutableObjectHistory< T >::try_save_timestamp().

Here is the call graph for this function:

selection_deserialized()

const Selection & Slic3r::UndoRedo::StackImpl::selection_deserialized ( ) const

inline

{ return m_selection; }

References m_selection.

set_memory_limit()

void Slic3r::UndoRedo::StackImpl::set_memory_limit ( size_t  memsize )

inline

{ m_memory_limit = memsize; }

References m_memory_limit, and memsize().

Here is the call graph for this function:

snapshot()

const Snapshot & Slic3r::UndoRedo::StackImpl::snapshot ( size_t  time ) const

inline

                                                        {
    const auto it = std::lower_bound(m_snapshots.cbegin(), m_snapshots.cend(), UndoRedo::Snapshot(time));
    assert(it != m_snapshots.end() && it->timestamp == time);
    return *it;
  }

References m_snapshots.

snapshots()

const std::vector< Snapshot > & Slic3r::UndoRedo::StackImpl::snapshots ( ) const

inline

{ return m_snapshots; }

References m_snapshots.

take_snapshot()

void Slic3r::UndoRedo::StackImpl::take_snapshot	(	const std::string &	snapshot_name,
		const Slic3r::Model &	model,
		const Slic3r::GUI::Selection &	selection,
		const Slic3r::GUI::GLGizmosManager &	gizmos,
		const SnapshotData &	snapshot_data
	)

{
  // Release old snapshot data.
  assert(m_active_snapshot_time <= m_current_time);
  for (auto &kvp : m_objects)
    kvp.second->release_after_timestamp(m_active_snapshot_time);
  bool topmost_saved = false;
  if (! m_snapshots.empty()) {
    // If the project was saved for the topmost snapshot, restore the "saved" state after the "topmost" snapshot is taken.
    topmost_saved = m_active_snapshot_time == m_saved_snapshot_time && m_active_snapshot_time == m_snapshots.back().timestamp;
    auto it = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(m_active_snapshot_time));
    this->release_snapshots(it, m_snapshots.end());
  }
  // Take new snapshots.
  this->save_mutable_object<Slic3r::Model>(model);
  m_selection.volumes_and_instances.clear();
  m_selection.volumes_and_instances.reserve(selection.get_volume_idxs().size());
  m_selection.mode = selection.get_mode();
  for (unsigned int volume_idx : selection.get_volume_idxs())
    m_selection.volumes_and_instances.emplace_back(selection.get_volume(volume_idx)->geometry_id);
  this->save_mutable_object<Selection>(m_selection);
    this->save_mutable_object<Slic3r::GUI::GLGizmosManager>(gizmos);
    // Save the snapshot info.
  m_snapshots.emplace_back(snapshot_name, m_current_time, model.id().id, snapshot_data);
  if (topmost_saved)
    // Restore the "saved" timestamp.
    m_saved_snapshot_time = m_current_time;
  m_active_snapshot_time = ++ m_current_time;
  // Save snapshot info of the last "current" aka "top most" state, that is only being serialized
  // if undoing an action. Such a snapshot has an invalid Model ID assigned if it was not taken yet.
  m_snapshots.emplace_back(topmost_snapshot_name, m_active_snapshot_time, 0, snapshot_data);
  // Release empty objects from the history.
  this->collect_garbage();
  assert(this->valid());
#ifdef SLIC3R_UNDOREDO_DEBUG
  std::cout << "After snapshot" << std::endl;
  this->print();
#endif /* SLIC3R_UNDOREDO_DEBUG */
}

References collect_garbage(), Slic3r::GLVolume::geometry_id, Slic3r::GUI::Selection::get_mode(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), Slic3r::ObjectID::id, Slic3r::ObjectBase::id(), m_active_snapshot_time, m_current_time, m_objects, m_saved_snapshot_time, m_selection, m_snapshots, Slic3r::UndoRedo::Selection::mode, release_snapshots(), Slic3r::UndoRedo::topmost_snapshot_name, valid(), and Slic3r::UndoRedo::Selection::volumes_and_instances.

Referenced by undo().

Here is the call graph for this function:

Here is the caller graph for this function:

temp_snapshot_active()

bool Slic3r::UndoRedo::StackImpl::temp_snapshot_active ( ) const

inline

{ return m_snapshots.back().timestamp == m_active_snapshot_time && ! m_snapshots.back().is_topmost_captured(); }

References m_active_snapshot_time, and m_snapshots.

undo()

bool Slic3r::UndoRedo::StackImpl::undo	(	Slic3r::Model &	model,
		const Slic3r::GUI::Selection &	selection,
		Slic3r::GUI::GLGizmosManager &	gizmos,
		const SnapshotData &	snapshot_data,
		size_t	jump_to_time
	)

{
  assert(this->valid());
  if (time_to_load == SIZE_MAX) {
    auto it_current = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(m_active_snapshot_time));
    if (-- it_current == m_snapshots.begin())
      return false;
    time_to_load = it_current->timestamp;
  }
  assert(time_to_load < m_active_snapshot_time);
  assert(std::binary_search(m_snapshots.begin(), m_snapshots.end(), Snapshot(time_to_load)));
  bool new_snapshot_taken = false;
  if (m_active_snapshot_time == m_snapshots.back().timestamp && ! m_snapshots.back().is_topmost_captured()) {
    // The current state is temporary. The current state needs to be captured to be redoable.
    //FIXME add new a "topmost" SnapshotType? 
        this->take_snapshot(topmost_snapshot_name, model, selection, gizmos, snapshot_data);
        // The line above entered another topmost_snapshot_name.
    assert(m_snapshots.back().is_topmost());
    assert(! m_snapshots.back().is_topmost_captured());
    // Pop it back, it is not needed as there is now a captured topmost state.
    m_snapshots.pop_back();
    // current_time was extended, but it should not cause any harm. Resetting it back may complicate the logic unnecessarily.
    //-- m_current_time;
    assert(m_snapshots.back().is_topmost());
    assert(m_snapshots.back().is_topmost_captured());
    new_snapshot_taken = true;
  }
    this->load_snapshot(time_to_load, model, gizmos);
  if (new_snapshot_taken) {
    // Release old snapshots if the memory allocated due to capturing the top most state is excessive.
    // Don't release the snapshots here, release them first after the scene and background processing gets updated, as this will release some references
    // to the shared TriangleMeshes.
    //this->release_least_recently_used();
  }
#ifdef SLIC3R_UNDOREDO_DEBUG
  std::cout << "After undo" << std::endl;
  this->print();
#endif /* SLIC3R_UNDOREDO_DEBUG */
  return true;
}

References load_snapshot(), m_active_snapshot_time, m_snapshots, SIZE_MAX, take_snapshot(), and valid().

Here is the call graph for this function:

valid()

bool Slic3r::UndoRedo::StackImpl::valid ( ) const

inline

                     {
    assert(! m_snapshots.empty());
    assert(m_snapshots.back().is_topmost());
    auto it = std::lower_bound(m_snapshots.begin(), m_snapshots.end(), Snapshot(m_active_snapshot_time));
    assert(it != m_snapshots.begin() && it != m_snapshots.end() && it->timestamp == m_active_snapshot_time);
    assert(m_active_snapshot_time <= m_snapshots.back().timestamp);
    for (auto it = m_objects.begin(); it != m_objects.end(); ++ it)
      assert(it->second->valid());
    return true;
  }

References m_active_snapshot_time, m_objects, and m_snapshots.

Referenced by has_redo_snapshot(), has_undo_snapshot(), load_snapshot(), redo(), release_least_recently_used(), take_snapshot(), and undo().

Here is the caller graph for this function:

Member Data Documentation

m_active_snapshot_time

size_t Slic3r::UndoRedo::StackImpl::m_active_snapshot_time

private

Referenced by active_snapshot_time(), clear(), empty(), has_redo_snapshot(), has_undo_snapshot(), has_undo_snapshot(), load_immutable_object(), load_mutable_object(), load_snapshot(), mark_current_as_saved(), project_modified(), redo(), reduce_noisy_snapshots(), release_least_recently_used(), save_immutable_object(), save_mutable_object(), take_snapshot(), temp_snapshot_active(), undo(), and valid().

m_current_time

size_t Slic3r::UndoRedo::StackImpl::m_current_time

private

Referenced by clear(), empty(), save_immutable_object(), save_mutable_object(), and take_snapshot().

m_memory_limit

size_t Slic3r::UndoRedo::StackImpl::m_memory_limit

private

Referenced by get_memory_limit(), release_least_recently_used(), and set_memory_limit().

m_objects

std::map<ObjectID, std::unique_ptr<ObjectHistoryBase> > Slic3r::UndoRedo::StackImpl::m_objects

private

Referenced by clear(), collect_garbage(), empty(), load_immutable_object(), load_mutable_object(), memsize(), reduce_noisy_snapshots(), release_least_recently_used(), save_immutable_object(), save_mutable_object(), take_snapshot(), and valid().

m_saved_snapshot_time

size_t Slic3r::UndoRedo::StackImpl::m_saved_snapshot_time { size_t(-1) }

private

Referenced by clear(), mark_current_as_saved(), project_modified(), release_snapshots(), and take_snapshot().

m_selection

Selection Slic3r::UndoRedo::StackImpl::m_selection

private

Referenced by clear(), load_snapshot(), selection_deserialized(), and take_snapshot().

m_shared_ptr_to_object_id

std::map<const void*, ObjectID> Slic3r::UndoRedo::StackImpl::m_shared_ptr_to_object_id

private

Referenced by clear(), collect_garbage(), immutable_object_id_impl(), and release_least_recently_used().

m_snapshots

std::vector<Snapshot> Slic3r::UndoRedo::StackImpl::m_snapshots

private

Referenced by clear(), empty(), has_redo_snapshot(), has_undo_snapshot(), has_undo_snapshot(), load_snapshot(), project_modified(), redo(), reduce_noisy_snapshots(), release_least_recently_used(), release_snapshots(), snapshot(), snapshots(), take_snapshot(), temp_snapshot_active(), undo(), and valid().

---

The documentation for this class was generated from the following file:

• src/slic3r/Utils/UndoRedo.cpp