error-log-display.hpp

Go to the documentation of this file.

/*
  ERROR-LOG-DISPLAY.hpp  -  display of error messages in a text box

  Copyright (C)         Lumiera.org
    2017,               Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef STAGE_WIDGET_ERROR_LOG_DISPLAY_H
#define STAGE_WIDGET_ERROR_LOG_DISPLAY_H

#include "stage/gtk-base.hpp"
#include "stage/style-scheme.hpp"
#include "stage/model/flash-deco.hpp"
#include "stage/model/expander-revealer.hpp"
#include "include/gui-notification-facade.h"
#include "lib/format-string.hpp"
#include "lib/symbol.hpp"
#include "lib/util.hpp"

#include <utility>
#include <vector>



namespace stage  {
namespace widget {
  
  using util::max;
  using util::_Fmt;
  using lib::Literal;
  using std::make_pair;
  using std::vector;
  using std::move;
  
  namespace {
    
    using Tag = Glib::RefPtr<Gtk::TextBuffer::Tag>;
    
    inline void
    populateStandardTextTags (Glib::RefPtr<TextBuffer::TagTable> tagTable)
    {
      Tag errorTag = Gtk::TextBuffer::Tag::create (cuString{TAG_ERROR});
      errorTag->property_background() = "Yellow";                
      errorTag->property_weight() = PANGO_WEIGHT_BOLD;
      tagTable->add (errorTag);
      
      Tag warnTag = Gtk::TextBuffer::Tag::create (cuString{TAG_WARN});
      warnTag->property_background() = "LightYellow";            
      tagTable->add (warnTag);
    }
  }
  
  
  
  /*********************************************************************/
  class ErrorLogDisplay
    : public Gtk::ScrolledWindow
    {
      
      using Mark = Glib::RefPtr<Gtk::TextBuffer::Mark>;
      using Entry = std::pair<Mark,Mark>;
      using TextWidget = model::FlashDeco<Gtk::TextView>;
      
      using SignalErrorChanged = sigc::signal<void, bool>;
      
      vector<Entry> errorMarks_;
      TextWidget    textLog_;
      
      SignalErrorChanged errorChangedSignal_;
      
      
    public:
     ~ErrorLogDisplay() { };
      
      ErrorLogDisplay()
        : Gtk::ScrolledWindow()
        , errorMarks_{}
        , textLog_{}
        {
          set_size_request (200, 80);           // must be > 50 for the scrollbar to work properly
          property_expand() = true;             // always grab any available additional space
          set_border_width (10);
          set_shadow_type  (Gtk::SHADOW_NONE);
          
          // the vertical scrollbar will always be necessary....
          set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);
          textLog_.set_editable (false);
          this->add (textLog_);
          
          populateStandardTextTags (textLog_.get_buffer()->get_tag_table());
        }
      
      model::Expander expand;
      model::Revealer reveal;
      
      
      void
      clearAll()
        {
          bool shallNotify = this->isError();
          
          errorMarks_.clear();
          size_t lineCnt = max (0, textLog_.get_buffer()->get_line_count() - 1);
          string placeholder;
          if (lineCnt > 0)
            placeholder = _Fmt{_("───════ %d preceding lines removed ════───\n")} % lineCnt;
          textLog_.get_buffer()->set_text (placeholder);  // discard existing content
          
          if (shallNotify)
            errorChangedSignal_.emit (false);
        }
      
      
      void
      addInfo (string text)
        {
          addEntry (text);
        }
      
      void
      addWarn (string text)
        {
          addEntry ("WARNING: "+text, TAG_WARN);
        }
      
      void
      addError (string text)
        {
          bool shallNotify = not this->isError();
          
          errorMarks_.emplace_back(
            addEntry ("ERROR: "+text, TAG_ERROR));
          if (not expand.isExpanded())
            expand (true);
          
          if (shallNotify)
            errorChangedSignal_.emit (true);
        }
      
      void
      clearInfoMsg()
        {
          auto newBuff = Gtk::TextBuffer::create (textLog_.get_buffer()->get_tag_table());
          vector<Entry> newMarks;
          for (Entry& entry : errorMarks_)
            {
              newBuff->insert (newBuff->end(), "\n");
              auto pos = newBuff->end();
              --pos;
              newMarks.emplace_back(
                make_pair (
                    newBuff->create_mark (pos, true),     // "left gravity" : stays to the left of inserted text
                    newBuff->create_mark (pos, false))); //  "right gravity": sticks right behind the inserted text))
              
              newBuff->insert (pos                     //    copy from old to new buffer, complete with formatting tag
                              ,entry.first->get_iter()
                              ,entry.second->get_iter()
                              );
            }
           // install the reduced new buffer
          auto oldBuff = textLog_.get_buffer();
          textLog_.set_buffer(newBuff);
          swap (errorMarks_, newMarks);
          
          // add a marker line to indicate the removed old log contents
          int oldLines = oldBuff->get_line_count();
          int newLines = newBuff->get_line_count();
          ASSERT (oldLines >= newLines);
          addInfo (_Fmt{_("───════ %d old log lines removed ════───\n")} % (oldLines-newLines));
        }
      
      
      void
      turnError_into_InfoMsg()
        {
          if (not isError()) return;
          
          auto buff = textLog_.get_buffer();
          for (Entry& entry : errorMarks_)
            {
              auto begin = entry.first->get_iter();
              auto end = entry.second->get_iter();
              
              buff->remove_tag_by_name(uString{TAG_ERROR}, begin,end);
              buff->apply_tag_by_name (uString{TAG_WARN},  begin,end);
            }
          errorMarks_.clear();
          errorChangedSignal_.emit (false);
        }
      
      
      void
      triggerFlash()
        {
          textLog_.flash();
        }
      
      
      /* ======= Error-State ======= */
      
      bool
      isError()  const
        {
          return not errorMarks_.empty();
        }
      
      SignalErrorChanged
      signalErrorChanged()
        {
          return errorChangedSignal_;
        }
      
      
      
    private:/* ===== Internals ===== */
      
      Entry
      addEntry (string const& text, Literal markupTagName =nullptr)
        {
          auto buff = textLog_.get_buffer();
          buff->insert (buff->end(), "\n");
          auto pos  = buff->end();
          --pos;
          auto begin = buff->create_mark (pos, true);  // "left gravity" : stays to the left of inserted text
          auto after = buff->create_mark (pos, false); // "right gravity": sticks right behind the inserted text
          if (markupTagName)
            buff->insert_with_tag(pos, text, cuString{markupTagName});
          else
            buff->insert (pos, text);
          textLog_.scroll_to (begin);
          return make_pair (move(begin), move(after));
        }
    };
  
  
}}// namespace stage::widget
#endif /*STAGE_WIDGET_ERROR_LOG_DISPLAY_H*/