[refactor][quickfix][Refs #31][WIP] Display object's content, but still a select_next issue

include/curseOutput.hh

@@ -128,8 +128,6 @@ class CurseOutput
         unsigned int write(const int &x, const int &y, JSonElement *item, unsigned int maxWidth, const OutputFlag);
         virtual unsigned int write(const int &x, const int &y, const std::string &item, const size_t len, unsigned int maxWidth, const OutputFlag) =0;
         virtual unsigned int write(const int &x, const int &y, const char item, unsigned int maxWidth, const OutputFlag) =0;
-        virtual bool writeKey(const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag) =0;
-        virtual bool writeKey(const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
 
         /**
          * prompt for user input, and return it

include/curseSimpleOutput.hh

@@ -42,6 +42,7 @@ class CurseSimpleOutput: public CurseOutput
         void write(const std::string &str, const OutputFlag flags) const;
         bool writeKey(const std::string &key, const size_t keylen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag, unsigned int extraLen =0);
         bool writeKey(const std::string &key, const size_t keylen, const std::string &after, size_t afterlen, t_Cursor &cursor, const t_Cursor &maxSize, OutputFlag flags);
+        bool writeKey(const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
         bool writeContainer(t_Cursor &, const t_Cursor &maxSize, const JSonContainer *);
         bool writeContent(t_Cursor &cursor, const t_Cursor &maxSize, std::list<JSonElement *> * obj);
         bool redraw(t_Cursor &, const t_Cursor &, JSonElement *);

include/curseSplitOutput.hh

@@ -7,6 +7,7 @@
 #include "jsonContainer.hh"
 
 class LevenshteinMatrice_base;
+class JSonObjectEntry;
 
 typedef struct
 {
@@ -43,8 +44,10 @@ class CurseSplitOutput: public CurseOutput
         bool isAdded(const JSonElement *e) const;
 
         bool writeContainer(const t_Cursor &maxSize, JSonContainer *, bool opening = true);
-        bool writeKey(const std::string &key, const size_t keylen, const t_Cursor &maxSize, OutputFlag flags, unsigned int extraLen =0);
-        bool writeKey(const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
+        bool writeObjectEntry(t_subWindow &w, const t_Cursor &maxSize, JSonObjectEntry *item);
+        bool writeKey(t_subWindow &, const std::string &key, const size_t keylen, const t_Cursor &maxSize, OutputFlag flags, unsigned int extraLen =0);
+        bool writeKey(t_subWindow &, const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
+        bool writeKey(t_subWindow &, const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
         unsigned int write(const int &x, const int &y, const char item, unsigned int maxWidth, OutputFlag flags);
         unsigned int write(const int &x, const int &y, const std::string &str, const size_t strlen, unsigned int maxWidth, const OutputFlag flags);
         void write(const std::string &str, const OutputFlag flags) const;

src/curseOutput.cpp

@@ -143,11 +143,6 @@ bool CurseOutput::redraw(const std::string &errorMsg)
     return result;
 }
 
-bool CurseOutput::writeKey(const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxSize, OutputFlag flags)
-{
-    return writeKey(key, keylen, after, after.size(), cursor, maxSize, flags);
-}
-
 unsigned int CurseOutput::write(const int &x, const int &y, JSonElement *item, unsigned int maxWidth, OutputFlag flags)
 {
     return write(x, y, item->stringify(), item->lazystrlen(), maxWidth, flags);

src/curseSimpleOutput.cpp

@@ -255,10 +255,10 @@ bool CurseSimpleOutput::writeContent(t_Cursor &cursor, const t_Cursor &maxSize,
             {
                 if (dynamic_cast<JSonObject *>(**ent))
                 {
-                    if (!CurseOutput::writeKey(key, ent->lazystrlen(), "{ ... }", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
+                    if (!writeKey(key, ent->lazystrlen(), "{ ... }", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
                         break;
                 }
-                else if (!CurseOutput::writeKey(key, ent->lazystrlen(), "[ ... ]", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
+                else if (!writeKey(key, ent->lazystrlen(), "[ ... ]", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
                     break;
             }
             else if (!isContainer)
@@ -271,10 +271,10 @@ bool CurseSimpleOutput::writeContent(t_Cursor &cursor, const t_Cursor &maxSize,
             {
                 if (dynamic_cast<const JSonObject *>(**ent) )
                 {
-                    if (!CurseOutput::writeKey(key, ent->lazystrlen(), "{ }", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
+                    if (!writeKey(key, ent->lazystrlen(), "{ }", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
                         break;
                 }
-                else if (!CurseOutput::writeKey(key, ent->lazystrlen(), "[ ]", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
+                else if (!writeKey(key, ent->lazystrlen(), "[ ]", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
                     break;
             }
             else
@@ -341,6 +341,11 @@ bool CurseSimpleOutput::writeKey(const std::string &key, const size_t keylen, co
     return (cursor.second >= scrollTop || (cursor.second - scrollTop) <= maxSize.second);
 }
 
+bool CurseSimpleOutput::writeKey(const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxSize, OutputFlag flags)
+{
+    return writeKey(key, keylen, after, after.size(), cursor, maxSize, flags);
+}
+
 unsigned int CurseSimpleOutput::write(const int &x, const int &y, const char item, unsigned int maxWidth, OutputFlag flags)
 {
     int offsetY = y - scrollTop;

src/curseSplitOutput.cpp

@@ -237,6 +237,8 @@ inputResult CurseSplitOutput::changeWindow(char d, bool c)
         return inputResult::nextInput;
     selectedWin = (selectedWin +d) % nbInputs;
     t_subWindow &w = subWindows.at(selectedWin);
+
+    //Restore selection
     if (!w.selection)
     {
         size_t i =0;
@@ -503,18 +505,18 @@ bool CurseSplitOutput::writeContainer(const t_Cursor &maxSize, JSonContainer *it
     else
         memcpy(childDelimiter, "[]", sizeof(*childDelimiter) * 2);
 
-    if (!opening)
+    if (!opening) // Display close brackets
     {
         w.cursor.first -= INDENT_LEVEL;
         w.cursor.second += write(w.cursor.first, w.cursor.second, childDelimiter[1], maxSize.first, CurseSplitOutput::getFlag(item));
     }
-    else if (collapsed.find((const JSonContainer *)item) != collapsed.end())
+    else if (collapsed.find((const JSonContainer *)item) != collapsed.end()) // inline collapsed
     {
         std::string ss;
         ss.append(&childDelimiter[0], 1).append(" ... ").append(&childDelimiter[1], 1);
         w.cursor.second += write(w.cursor.first, w.cursor.second, ss, 7, maxSize.first, CurseSplitOutput::getFlag(item));
     }
-    else
+    else // Display open brackets
     {
         w.cursor.second += write(w.cursor.first, w.cursor.second, childDelimiter[0], maxSize.first, CurseSplitOutput::getFlag(item));
         if (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1)
@@ -526,10 +528,8 @@ bool CurseSplitOutput::writeContainer(const t_Cursor &maxSize, JSonContainer *it
     return (w.cursor.second < w.scrollTop || (w.cursor.second - w.scrollTop) <= maxSize.second -1);
 }
 
-bool CurseSplitOutput::writeKey(const std::string &key, const size_t keylen, const t_Cursor &maxSize, OutputFlag flags, unsigned int extraLen)
+bool CurseSplitOutput::writeKey(t_subWindow &w, const std::string &key, const size_t keylen, const t_Cursor &maxSize, OutputFlag flags, unsigned int extraLen)
 {
-    t_subWindow &w = subWindows.at(workingWin);
-
     if (w.cursor.second <= w.scrollTop)
     {
         w.cursor.second++;
@@ -544,10 +544,8 @@ bool CurseSplitOutput::writeKey(const std::string &key, const size_t keylen, con
     return (w.cursor.second < w.scrollTop || (w.cursor.second - w.scrollTop) <= maxSize.second);
 }
 
-bool CurseSplitOutput::writeKey(const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag flags)
+bool CurseSplitOutput::writeKey(t_subWindow &w, const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag flags)
 {
-    t_subWindow &w = subWindows.at(workingWin);
-
     if (cursor.second <= w.scrollTop)
     {
         cursor.second++;
@@ -564,6 +562,11 @@ bool CurseSplitOutput::writeKey(const std::string &key, const size_t keylen, con
     return (cursor.second < w.scrollTop || (cursor.second - w.scrollTop) <= maxWidth.second);
 }
 
+bool CurseSplitOutput::writeKey(t_subWindow &w, const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag flags)
+{
+    return writeKey(w, key, keylen, after, after.length(), cursor, maxWidth, flags);
+}
+
 bool CurseSplitOutput::isAdded(const JSonElement *e) const
 {
     return diffMatrice->getEquivalence(e) == nullptr;
@@ -602,6 +605,10 @@ bool CurseSplitOutput::redraw(t_subWindow &w, const t_Cursor &maxSize, JSonEleme
         if (!writeContainer(maxSize, (JSonContainer *) item))
             return false;
     }
+    else if (dynamic_cast<JSonObjectEntry*>(item))
+    {
+        return writeObjectEntry(w, maxSize, (JSonObjectEntry*) item);
+    }
     else
     {
         w.cursor.second += CurseOutput::write(w.cursor.first, w.cursor.second, item, maxSize.first, CurseSplitOutput::getFlag(item));
@@ -611,6 +618,50 @@ bool CurseSplitOutput::redraw(t_subWindow &w, const t_Cursor &maxSize, JSonEleme
     return true;
 }
 
+bool CurseSplitOutput::writeObjectEntry(t_subWindow &w, const t_Cursor &maxSize, JSonObjectEntry *ent)
+{
+    bool isContainer = (dynamic_cast<JSonContainer *>(**ent) != nullptr);
+    std::string key = ent->stringify();
+
+    checkSelection(ent);
+    if (isContainer && collapsed.find((JSonContainer*)(**ent)) != collapsed.cend()) // inline collapsed container
+    {
+        if (dynamic_cast<JSonObject *>(**ent))
+        {
+            if (!writeKey(w, key, ent->lazystrlen(), "{ ... }", w.cursor, maxSize, getFlag(ent)) || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
+                return false;
+        }
+        else if (!writeKey(w, key, ent->lazystrlen(), "[ ... ]", w.cursor, maxSize, getFlag(ent)) || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
+            return false;
+    }
+    else if (!isContainer) // inline value
+    {
+        JSonElement *eContent = **ent;
+        if (!writeKey(w, key, ent->lazystrlen(), eContent->stringify(), eContent->lazystrlen(), w.cursor, maxSize, getFlag(ent))
+                || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
+            return false;
+    }
+    else if (((JSonContainer*)(**ent))->size() == 0) // inline empty
+    {
+        if (dynamic_cast<const JSonObject *>(**ent) )
+        {
+            if (!writeKey(w, key, ent->lazystrlen(), "{ }", w.cursor, maxSize, getFlag(ent)) || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
+                return false;
+        }
+        else if (!writeKey(w, key, ent->lazystrlen(), "[ ]", w.cursor, maxSize, getFlag(ent)) || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
+            return false;
+    }
+    else // Container
+    {
+        if (!writeKey(w, key, ent->lazystrlen(), maxSize, getFlag(ent)))
+            return false;
+        writeContainer(maxSize, (JSonContainer*)(**ent), true);
+    }
+    if (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1)
+        return false;
+    return true;
+}
+
 unsigned int CurseSplitOutput::write(const int &x, const int &y, const char item, unsigned int maxWidth, OutputFlag flags)
 {
     int offsetY = y - subWindows.at(workingWin).scrollTop;
@@ -766,7 +817,8 @@ const OutputFlag CurseSplitOutput::getFlag(const JSonElement *item, const JSonEl
     OutputFlag res;
     const JSonElement *i = dynamic_cast<const JSonObjectEntry*>(item) ? **((const JSonObjectEntry*)item) : item;
 
-    res.selected(item == selection);
+    res.selected(item == selection
+            || (item->getParent() && dynamic_cast<const JSonObjectEntry*>(item->getParent()) && selection == item->getParent()));
     res.searched(std::find(subWindows.at(selectedWin).searchResults.cbegin(),
                 subWindows.at(selectedWin).searchResults.cend(),
                 item) != subWindows.at(selectedWin).searchResults.cend());

test/testDiffObjSimple.3.json

@@ -0,0 +1 @@
+{"a":[1, 2, 4]}