cppconsui/TextView.cpp

   1 // Copyright (C) 2010-2015 Petr Pavlu <setup@dagobah.cz>
   2 //
   3 // This file is part of CenterIM.
   4 //
   5 // CenterIM is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // CenterIM is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with CenterIM.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /// @file
  19 /// TextView class implementation.
  20 ///
  21 /// @ingroup cppconsui
  22
  23 #include "TextView.h"
  24
  25 #include "ColorScheme.h"
  26
  27 #include <cassert>
  28 #include <cstdio>
  29 #include <cstring>
  30
  31 namespace CppConsUI {
  32
  33 TextView::TextView(int w, int h, bool autoscroll, bool scrollbar)
  34   : Widget(w, h), view_top_(0), autoscroll_(autoscroll),
  35     autoscroll_suspended_(false), scrollbar_(scrollbar)
  36 {
  37   can_focus_ = true;
  38   declareBindables();
  39 }
  40
  41 TextView::~TextView()
  42 {
  43   clear();
  44 }
  45
  46 int TextView::draw(Curses::ViewPort area, Error &error)
  47 {
  48   DRAW(area.erase(error));
  49
  50   if (screen_lines_.size() <= static_cast<unsigned>(real_height_)) {
  51     view_top_ = 0;
  52     autoscroll_suspended_ = false;
  53   }
  54   else if (view_top_ > screen_lines_.size() - real_height_) {
  55     view_top_ = screen_lines_.size() - real_height_;
  56     autoscroll_suspended_ = false;
  57   }
  58   else if (autoscroll_ && !autoscroll_suspended_)
  59     view_top_ = screen_lines_.size() - real_height_;
  60
  61   int attrs;
  62   DRAW(getAttributes(ColorScheme::PROPERTY_TEXTVIEW_TEXT, &attrs, error));
  63   DRAW(area.attrOn(attrs, error));
  64
  65   ScreenLines::iterator i;
  66   int j;
  67   for (i = screen_lines_.begin() + view_top_, j = 0;
  68        i != screen_lines_.end() && j < real_height_; ++i, ++j) {
  69     int attrs2 = 0;
  70     if (i->parent->color != 0) {
  71       DRAW(getAttributes(
  72         ColorScheme::PROPERTY_TEXTVIEW_TEXT, i->parent->color, &attrs2, error));
  73       DRAW(area.attrOff(attrs, error));
  74       DRAW(area.attrOn(attrs2, error));
  75     }
  76
  77     const char *p = i->text;
  78     int w = 0;
  79     for (int k = 0; k < i->length; ++k) {
  80       UTF8::UniChar uc = UTF8::getUniChar(p);
  81       int printed;
  82       if (uc == '\t') {
  83         printed = Curses::onScreenWidth(uc, w);
  84         for (int l = 0; l < printed; ++l)
  85           DRAW(area.addChar(w + l, j, ' ', error));
  86       }
  87       else
  88         DRAW(area.addChar(w, j, uc, error, &printed));
  89       w += printed;
  90       p = UTF8::getNextChar(p);
  91     }
  92
  93     if (i->parent->color != 0) {
  94       DRAW(area.attrOff(attrs2, error));
  95       DRAW(area.attrOn(attrs, error));
  96     }
  97   }
  98
  99   DRAW(area.attrOff(attrs, error));
 100
 101   // Draw scrollbar.
 102   if (scrollbar_) {
 103     int x1, x2;
 104     if (screen_lines_.size() <= static_cast<unsigned>(real_height_)) {
 105       x1 = 0;
 106       x2 = real_height_;
 107     }
 108     else {
 109       x2 = static_cast<float>(view_top_ + real_height_) * real_height_ /
 110         screen_lines_.size();
 111       // Calculate x1 based on x2 (not based on view_top_) to avoid jittering
 112       // during rounding.
 113       x1 = x2 - real_height_ * real_height_ / screen_lines_.size();
 114     }
 115
 116     int attrs;
 117     DRAW(
 118       getAttributes(ColorScheme::PROPERTY_TEXTVIEW_SCROLLBAR, &attrs, error));
 119     attrs |= Curses::Attr::REVERSE;
 120     DRAW(area.attrOn(attrs, error));
 121
 122     for (int i = x1 + 1; i < x2 - 1; ++i)
 123       DRAW(area.addChar(real_width_ - 1, i, ' ', error));
 124
 125     if (x2 - x1 < 2) {
 126       // This is a special case when x1 is too close to x2, but we need to draw
 127       // at least two arrows.
 128       if (real_height_ - x1 < 2) {
 129         // We are close to bottom position.
 130         DRAW(area.addLineChar(
 131           real_width_ - 1, real_height_ - 2, Curses::LINE_UARROW, error));
 132         DRAW(area.addLineChar(
 133           real_width_ - 1, real_height_ - 1, Curses::LINE_DARROW, error));
 134       }
 135       else if (x2 < 2) {
 136         // We are close to top position.
 137         DRAW(area.addLineChar(real_width_ - 1, 0, Curses::LINE_UARROW, error));
 138         DRAW(area.addLineChar(real_width_ - 1, 1, Curses::LINE_DARROW, error));
 139       }
 140       else {
 141         // In between.
 142         DRAW(area.addLineChar(
 143           real_width_ - 1, x2 - 2, Curses::LINE_UARROW, error));
 144         DRAW(area.addLineChar(
 145           real_width_ - 1, x2 - 1, Curses::LINE_DARROW, error));
 146       }
 147     }
 148     else {
 149       // Scrollbar length is big enough to fit two arrows.
 150       DRAW(area.addLineChar(real_width_ - 1, x1, Curses::LINE_UARROW, error));
 151       DRAW(
 152         area.addLineChar(real_width_ - 1, x2 - 1, Curses::LINE_DARROW, error));
 153     }
 154
 155     // Draw a dot to indicate "end of scrolling" for users.
 156     if (view_top_ + real_height_ >= screen_lines_.size())
 157       DRAW(area.addLineChar(
 158         real_width_ - 1, real_height_ - 1, Curses::LINE_BULLET, error));
 159     if (view_top_ == 0)
 160       DRAW(area.addLineChar(real_width_ - 1, 0, Curses::LINE_BULLET, error));
 161
 162     DRAW(area.attrOff(attrs, error));
 163   }
 164
 165   /*
 166   char pos[128];
 167   g_snprintf(pos, sizeof(pos), "%d/%d ", view_top_, screen_lines_.size());
 168   DRAW(area.addString(0, 0, pos));
 169   */
 170
 171   return 0;
 172 }
 173
 174 void TextView::append(const char *text, int color)
 175 {
 176   insert(lines_.size(), text, color);
 177 }
 178
 179 void TextView::insert(std::size_t line_num, const char *text, int color)
 180 {
 181   if (text == nullptr)
 182     return;
 183
 184   assert(line_num <= lines_.size());
 185
 186   const char *p = text;
 187   const char *s = text;
 188   std::size_t cur_line_num = line_num;
 189
 190   // Parse lines.
 191   while (*p != '\0') {
 192     if (*p == '\n') {
 193       auto l = new Line(s, p - s, color);
 194       lines_.insert(lines_.begin() + cur_line_num, l);
 195       ++cur_line_num;
 196       s = p = UTF8::getNextChar(p);
 197       continue;
 198     }
 199
 200     p = UTF8::getNextChar(p);
 201   }
 202
 203   if (s < p) {
 204     auto l = new Line(s, p - s, color);
 205     lines_.insert(lines_.begin() + cur_line_num, l);
 206     ++cur_line_num;
 207   }
 208
 209   // Update screen lines.
 210   std::size_t advice = cur_line_num == lines_.size() ? screen_lines_.size() : 0;
 211   for (std::size_t i = line_num; i < cur_line_num; ++i)
 212     advice = updateScreenLines(i, advice);
 213
 214   redraw();
 215 }
 216
 217 void TextView::erase(std::size_t line_num)
 218 {
 219   assert(line_num < lines_.size());
 220
 221   eraseScreenLines(line_num, 0);
 222   delete lines_[line_num];
 223   lines_.erase(lines_.begin() + line_num);
 224
 225   redraw();
 226 }
 227
 228 void TextView::erase(std::size_t start_line, std::size_t end_line)
 229 {
 230   assert(start_line < lines_.size());
 231   assert(end_line <= lines_.size());
 232   assert(start_line <= end_line);
 233
 234   std::size_t advice = 0;
 235   for (std::size_t i = start_line; i < end_line; ++i)
 236     advice = eraseScreenLines(i, advice);
 237   for (std::size_t i = start_line; i < end_line; ++i)
 238     delete lines_[i];
 239   lines_.erase(lines_.begin() + start_line, lines_.begin() + end_line);
 240
 241   redraw();
 242 }
 243
 244 void TextView::clear()
 245 {
 246   for (Line *line : lines_)
 247     delete line;
 248   lines_.clear();
 249
 250   screen_lines_.clear();
 251
 252   redraw();
 253 }
 254
 255 const char *TextView::getLine(std::size_t line_num) const
 256 {
 257   assert(line_num < lines_.size());
 258
 259   return lines_[line_num]->text;
 260 }
 261
 262 std::size_t TextView::getLinesNumber() const
 263 {
 264   return lines_.size();
 265 }
 266
 267 void TextView::setAutoScroll(bool new_autoscroll)
 268 {
 269   if (new_autoscroll == autoscroll_)
 270     return;
 271
 272   autoscroll_ = new_autoscroll;
 273   redraw();
 274 }
 275
 276 void TextView::setScrollBar(bool new_scrollbar)
 277 {
 278   if (new_scrollbar == scrollbar_)
 279     return;
 280
 281   scrollbar_ = new_scrollbar;
 282   updateAllScreenLines();
 283   redraw();
 284 }
 285
 286 TextView::Line::Line(const char *text_, std::size_t bytes, int color_)
 287   : color(color_)
 288 {
 289   assert(text_ != nullptr);
 290
 291   text = new char[bytes + 1];
 292   std::strncpy(text, text_, bytes);
 293   text[bytes] = '\0';
 294
 295   length = 0;
 296   const char *p = text;
 297   while (p != nullptr && *p != '\0') {
 298     ++length;
 299     p = UTF8::getNextChar(p);
 300   }
 301 }
 302
 303 TextView::Line::~Line()
 304 {
 305   delete[] text;
 306 }
 307
 308 TextView::ScreenLine::ScreenLine(Line &parent_, const char *text_, int length_)
 309   : parent(&parent_), text(text_), length(length_)
 310 {
 311 }
 312
 313 void TextView::updateArea()
 314 {
 315   updateAllScreenLines();
 316 }
 317
 318 const char *TextView::proceedLine(
 319   const char *text, int area_width, int *res_length) const
 320 {
 321   assert(text != nullptr);
 322   assert(area_width > 0);
 323   assert(res_length != nullptr);
 324
 325   const char *cur = text;
 326   const char *res = text;
 327   int prev_width = 0;
 328   int cur_width = 0;
 329   int cur_length = 0;
 330   bool space = false;
 331   *res_length = 0;
 332
 333   while (*cur != '\0') {
 334     prev_width = cur_width;
 335     UTF8::UniChar uc = UTF8::getUniChar(cur);
 336     cur_width += Curses::onScreenWidth(uc, cur_width);
 337     ++cur_length;
 338
 339     if (prev_width > area_width)
 340       break;
 341
 342     // Possibly too long word.
 343     if (cur_width > area_width && *res_length == 0) {
 344       *res_length = cur_length - 1;
 345       res = cur;
 346     }
 347
 348     if (UTF8::isUniCharSpace(uc))
 349       space = true;
 350     else if (space) {
 351       // Found start of a word and everything before that can fit into one
 352       // screen line.
 353       *res_length = cur_length - 1;
 354       res = cur;
 355       space = false;
 356     }
 357
 358     cur = UTF8::getNextChar(cur);
 359   }
 360
 361   // End of text.
 362   if (*cur == '\0' && cur_width <= area_width) {
 363     *res_length = cur_length;
 364     res = cur;
 365   }
 366
 367   // Fix for very small area_width and characters wider that 1 cell. For
 368   // example, area_width = 1 and text = "W" where W is a wide character (2 cells
 369   // width) (or simply for tabs). In that case we can not draw anything but we
 370   // want to skip to another character.
 371   if (res == text)
 372     res = UTF8::getNextChar(res);
 373
 374   return res;
 375 }
 376
 377 std::size_t TextView::updateScreenLines(std::size_t line_num, std::size_t start)
 378 {
 379   assert(line_num < lines_.size());
 380   assert(start <= screen_lines_.size());
 381
 382   // Find where new screen lines should be placed and remove previous screen
 383   // lines created for this line.
 384   ScreenLines::iterator i =
 385     screen_lines_.begin() + eraseScreenLines(line_num, start);
 386
 387   // Parse line into screen lines.
 388   ScreenLines new_lines;
 389   const char *p = lines_[line_num]->text;
 390   const char *s;
 391
 392   int realw = real_width_;
 393   if (scrollbar_ && realw > 2) {
 394     // Scrollbar shrinks the width of the view area.
 395     realw -= 2;
 396   }
 397
 398   if (realw <= 0)
 399     return 0;
 400
 401   int len;
 402   while (*p != '\0') {
 403     s = p;
 404     p = proceedLine(p, realw, &len);
 405     new_lines.push_back(ScreenLine(*lines_[line_num], s, len));
 406   }
 407
 408   // Empty line.
 409   if (new_lines.empty())
 410     new_lines.push_back(ScreenLine(*lines_[line_num], p, 0));
 411
 412   std::size_t res = i - screen_lines_.begin() + new_lines.size();
 413   screen_lines_.insert(i, new_lines.begin(), new_lines.end());
 414
 415   return res;
 416 }
 417
 418 void TextView::updateAllScreenLines()
 419 {
 420   // Delete all screen lines.
 421   screen_lines_.clear();
 422
 423   /// @todo Save and restore scroll afterwards.
 424   for (std::size_t i = 0, advice = 0; i < lines_.size(); ++i)
 425     advice = updateScreenLines(i, advice);
 426 }
 427
 428 std::size_t TextView::eraseScreenLines(
 429   std::size_t line_num, std::size_t start, std::size_t *deleted)
 430 {
 431   assert(line_num < lines_.size());
 432   assert(start <= screen_lines_.size());
 433
 434   std::size_t i = start;
 435   bool begin_set = false, end_set = false;
 436   // Note, the assigment to the begin variable is only to silence a compiler
 437   // warning. The use of the variable is protected by the begin_set variable.
 438   std::size_t begin = 0, end;
 439   while (i < screen_lines_.size()) {
 440     if (screen_lines_[i].parent == lines_[line_num]) {
 441       if (!begin_set) {
 442         begin = i;
 443         begin_set = true;
 444       }
 445     }
 446     else if (begin_set) {
 447       end = i;
 448       end_set = true;
 449       break;
 450     }
 451     ++i;
 452   }
 453   if (begin_set) {
 454     if (!end_set)
 455       end = screen_lines_.size();
 456     screen_lines_.erase(
 457       screen_lines_.begin() + begin, screen_lines_.begin() + end);
 458     i -= end - begin;
 459     if (deleted != nullptr)
 460       *deleted = end - begin;
 461   }
 462   else if (deleted != nullptr)
 463     *deleted = 0;
 464
 465   return i;
 466 }
 467
 468 void TextView::actionScroll(int direction)
 469 {
 470   if (screen_lines_.size() <= static_cast<unsigned>(real_height_))
 471     return;
 472
 473   unsigned s = abs(direction) * ((real_height_ + 1) / 2);
 474   if (direction < 0) {
 475     if (view_top_ < s)
 476       view_top_ = 0;
 477     else
 478       view_top_ -= s;
 479   }
 480   else {
 481     if (view_top_ + s > screen_lines_.size() - real_height_)
 482       view_top_ = screen_lines_.size() - real_height_;
 483     else
 484       view_top_ += s;
 485   }
 486
 487   autoscroll_suspended_ = screen_lines_.size() > view_top_ + real_height_;
 488   redraw();
 489 }
 490
 491 void TextView::declareBindables()
 492 {
 493   declareBindable("textview", "scroll-up",
 494     sigc::bind(sigc::mem_fun(this, &TextView::actionScroll), -1),
 495     InputProcessor::BINDABLE_NORMAL);
 496
 497   declareBindable("textview", "scroll-down",
 498     sigc::bind(sigc::mem_fun(this, &TextView::actionScroll), 1),
 499     InputProcessor::BINDABLE_NORMAL);
 500 }
 501
 502 } // namespace CppConsUI
 503
 504 // vim: set tabstop=2 shiftwidth=2 textwidth=80 expandtab: