buffer.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include "colors.h"
#include <vector>
#include "utils.h"
#include "key_cmd_map.h"
#include "command.h"
#include "line.h"
#include "mode.h"
#include "pos2d.h"
#include <stack>
#include <vector>
#include <unordered_set>
#include "file_utils.h"
#include "parser/nfa.h"
 
namespace teditor {
 
class Editor;
class Window;
 
 
class Buffer {
public:
  Buffer(const std::string& name="", bool noUndoRedo=false);
  virtual ~Buffer() {}
 
  virtual void insert(char c);
  virtual void insert(const std::string& str);
  void remove(bool removeCurrent=false);
  std::string removeAndCopy();
  std::string removeRegion(const Point& start, const Point& end);
  std::string killLine(bool pushToStack=true);
  void sortRegion();
  void keepRemoveLines(parser::NFA& regex, bool keep);
  virtual void clear();
  bool undo();
  bool redo();
  bool matchCurrentParen();
 
  virtual void load(const std::string& file, int line=0);
 
  int length() const { return (int)lines.size(); }
 
  Line& at(int idx) { return lines[idx]; }
  const Line& at(int idx) const { return lines[idx]; }
  Point buffer2screen(const Point& loc, const Point& start,
                      const Point& dim) const;
  Point screen2buffer(const Point& loc, const Point& start,
                       const Point& dim) const;
  char charAt(const Point& pos) const;
 
  virtual void draw(Editor& ed, const Window& win);
  void drawPoint(Editor& ed, const AttrColor& bg, const Window& win);
  void startOfLine() { longestX = cu.x = getMinStartLoc(); }
  void endOfLine() { longestX = cu.x = lengthOf(cu.y); }
  void left();
  void right();
  void down();
  void up();
  void begin();
  void end();
  void pageDown(int ijump);
  void pageUp(int ijump);
  void nextPara();
  void previousPara();
  void nextWord();
  void previousWord();
  void gotoLine(int lineNum, const Point& dim);
  bool hasPointOn(int line) const { return line == cu.y; }
  const Point& getPoint() const { return cu; }
  void setPoint(const Point& p) { cu = p; }
  bool isRegionActive() const { return region != Point(-1, -1); }
  std::string regionAsStr() const;
  std::string regionAsStr(const Point& start, const Point& end) const;
  void startRegion() { region = cu; }
  void stopRegion() { region = Point(-1, -1); }
  const Point& getRegion() const { return region; }
  int lengthOf(int i) const { return lines[i].length(); }
 
  void indent();
 
  virtual int totalLinesNeeded(const Point& dim) const;
 
  virtual void lineUp(const Point& dim);
  virtual void lineDown();
  void lineReset() { startLine = 0; }
  void lineEnd(const Point& start, const Point& dim);
  virtual bool save(const std::string& fName="");
  const std::string& bufferName() const { return buffName; }
  const std::string& getFileName() const { return fileName; }
  const std::string& pwd() const { return dirName; }
  bool isRO() const { return readOnly; }
  bool isModified() const { return modified; }
  virtual int getMinStartLoc() const { return 0; }
  std::string dirModeGetFileAtLine(int line);
 
  void reload();
  const AttrColor& getColor(const std::string& name) const;
  const std::string& getWord() const { return mode->word(); }
  const std::string& modeName() const { return mode->name(); }
  void makeReadOnly();
  void setMode(ModePtr m) { mode = m; }
 
  template <typename ModeT>
  ModeT* getMode(const std::string& name) {
    ASSERT(modeName() == name, "getMode: expected '%s' but obtained '%s'!",
           name.c_str(), modeName().c_str());
    return dynamic_cast<ModeT*>(mode.get());
  }
 
  Strings cmdNames() const { return mode->cmdNames(); }
 
protected:
  struct RemovedLine {
    std::string str;
    int num;
  };
  typedef std::vector<RemovedLine> RemovedLines;
 
 
  enum OpType {
    OpInsert = 0,
    OpDelete,
    OpKillLine,
    OpKeepRemoveLines,
  };
 
 
  struct OpData {
    Point before;
    Point after;
    std::string str;
    RemovedLines rlines;
    OpType type;
  }; // end class OpData
 
 
  typedef std::stack<OpData> OpStack;
 
 
  std::vector<Line> lines;
  int startLine;
  bool modified, readOnly;
  std::string buffName, fileName, dirName, tmpFileName;
  Point region;
  ModePtr mode;
  Point cu;
  int longestX;
  OpStack undoStack;
  OpStack redoStack;
  bool disableStack;
 
 
  void insertImpl(char c);
  void addLine() { lines.push_back(Line()); }
  void resetBufferState(int line, const std::string& file, bool dir);
  KeyCmdMap& getKeyCmdMap() { return mode->getKeyCmdMap(); }
  void loadFile(const std::string& file, int line);
  void loadDir(const std::string& dir);
  std::string removeFrom(const Point& start, const Point& end);
  Point matchCurrentParen(bool& isOpen);
  int dirModeFileOffset() const { return FilePerm::DirModeFileOffset; }
 
 
  void drawStatusBar(Editor& ed, const Window& win);
  virtual int drawLine(int y, const std::string& line, Editor& ed, int lineNum,
                       const Window &win);
  std::string removeChar();
  std::string removeCurrentChar();
  void applyInsertOp(OpData& op, bool pushToStack=true);
  void applyDeleteOp(OpData& op);
  void addLines(const RemovedLines& rlines);
  void removeLines(const RemovedLines& rlines);
  void pushNewOp(OpData& op);
  void clearStack(OpStack& st);
  friend class Editor;
};
 
 
class Buffers : public std::vector<Buffer*> {
public:
  ~Buffers();
 
  Buffer* push_back(const std::string& name, bool noUndoRedo = false);
  void push_back(Buffer* buf);
 
  void clear();
  void erase(int idx);
 
  Strings namesList() const;
 
 
private:
  std::unordered_set<std::string> buffNames;
 
  std::string uniquify(const std::string& name) const;
};
 
}; // end namespace teditor