undoAppOpenDocuments.hpp

Go to the documentation of this file.

 
#ifndef UNDOSTUDIO_UNDOAPP_OPENDOCUMENTS_HPP
#define UNDOSTUDIO_UNDOAPP_OPENDOCUMENTS_HPP
 
#include <cstddef>
#include <string>
#include <vector>
 
namespace undoApp {
 
enum class DocKind
{
   None,
   ST,
   JSON,
   Text,
   Cpp
};
 
struct OpenDocument
{
   std::string path;      
   DocKind kind = DocKind::None;
   bool pinned = false;   
   bool dirty = false;    
};
 
struct OpenOutcome
{
   bool alreadyOpen = false;    
   bool droppedPreview = false; 
   std::string droppedPath;     
};
 
class OpenDocuments
{
public:
   OpenOutcome open(const std::string& path, DocKind kind)
   {
      OpenOutcome outcome;
      if (path.empty()) {
         return outcome;
      }
      for (OpenDocument& doc : m_documents) {
         if (doc.path == path) {
            m_active = path;
            outcome.alreadyOpen = true;
            return outcome;
         }
      }
 
      // The outgoing preview. There is only ever one, which is what makes browsing
      // a tree cheap: it is a slot that the next file takes rather than a tab per
      // file passed over.
      //
      // A dirty preview cannot be reached here. setDirty() pins a document the
      // moment it gains changes, so anything still in the slot has none to lose.
      for (size_t i = 0; i < m_documents.size(); ++i) {
         if (m_documents[i].pinned) {
            continue;
         }
         outcome.droppedPath = m_documents[i].path;
         m_documents.erase(m_documents.begin() + static_cast<long>(i));
         outcome.droppedPreview = true;
         break;
      }
 
      OpenDocument doc;
      doc.path = path;
      doc.kind = kind;
      m_documents.push_back(doc);
      m_active = path;
      return outcome;
   }
 
   bool pin(const std::string& path)
   {
      for (OpenDocument& doc : m_documents) {
         if (doc.path == path) {
            doc.pinned = true;
            return true;
         }
      }
      return false;
   }
 
   void setDirty(const std::string& path, bool dirty)
   {
      for (OpenDocument& doc : m_documents) {
         if (doc.path != path) {
            continue;
         }
         doc.dirty = dirty;
         if (dirty) {
            doc.pinned = true;
         }
         return;
      }
   }
 
   void setClean(const std::string& path) { setDirty(path, false); }
 
   struct CloseOutcome
   {
      bool closed = false;
      std::string nextActive;
      bool activeWasClosed = false;
   };
 
   CloseOutcome close(const std::string& path)
   {
      CloseOutcome outcome;
      for (size_t i = 0; i < m_documents.size(); ++i) {
         if (m_documents[i].path != path) {
            continue;
         }
         outcome.activeWasClosed = (m_active == path);
         outcome.closed = true;
         m_documents.erase(m_documents.begin() + static_cast<long>(i));
         if (outcome.activeWasClosed) {
            // The tab to the left, or the first one left, so closing does not jump
            // to whatever happens to be at the end of the list.
            m_active = m_documents.empty() ? std::string()
                                           : m_documents[(i > 0) ? i - 1 : 0].path;
            outcome.nextActive = m_active;
         }
         return outcome;
      }
      return outcome;
   }
 
   bool rename(const std::string& oldPath, const std::string& newPath)
   {
      if (newPath.empty() || oldPath == newPath || isOpen(newPath)) {
         return false;
      }
      for (OpenDocument& doc : m_documents) {
         if (doc.path != oldPath) {
            continue;
         }
         doc.path = newPath;
         if (m_active == oldPath) {
            m_active = newPath;
         }
         return true;
      }
      return false;
   }
 
   bool activate(const std::string& path)
   {
      for (const OpenDocument& doc : m_documents) {
         if (doc.path == path) {
            m_active = path;
            return true;
         }
      }
      return false;
   }
 
   struct DirtySummary
   {
      size_t closed = 0;
      size_t dirty = 0;
   };
 
   DirtySummary closeAll()
   {
      DirtySummary summary;
      for (const OpenDocument& doc : m_documents) {
         if (doc.dirty) {
            ++summary.dirty;
         }
      }
      summary.closed = m_documents.size();
      m_documents.clear();
      m_active.clear();
      return summary;
   }
 
   const std::vector<OpenDocument>& documents() const { return m_documents; }
   const std::string& active() const { return m_active; }
   size_t size() const { return m_documents.size(); }
 
   bool isOpen(const std::string& path) const
   {
      for (const OpenDocument& doc : m_documents) {
         if (doc.path == path) {
            return true;
         }
      }
      return false;
   }
 
   size_t pinnedCount() const
   {
      size_t count = 0;
      for (const OpenDocument& doc : m_documents) {
         if (doc.pinned) {
            ++count;
         }
      }
      return count;
   }
 
   const std::string* cycle(int direction)
   {
      if (m_documents.empty()) {
         return nullptr;
      }
      int index = -1;
      for (size_t i = 0; i < m_documents.size(); ++i) {
         if (m_documents[i].path == m_active) {
            index = static_cast<int>(i);
            break;
         }
      }
      const int count = static_cast<int>(m_documents.size());
      // With nothing active, "next" starts at the beginning and "previous" at the
      // end, so either key goes somewhere rather than jumping to the first twice.
      int next = (index < 0) ? (direction >= 0 ? 0 : count - 1) : (index + direction + count) % count;
      m_active = m_documents[static_cast<size_t>(next)].path;
      return &m_active;
   }
 
private:
   std::vector<OpenDocument> m_documents;
   std::string m_active;
};
 
} // namespace undoApp
 
#endif // UNDOSTUDIO_UNDOAPP_OPENDOCUMENTS_HPP