src/scrollpad.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2009 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program 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  *   This program 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 this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include <cassert>
  22
  23 #include "scrollpad.h"
  24
  25 using namespace NCurses;
  26
  27 Scrollpad::Scrollpad(size_t startx,
  28                         size_t starty,
  29                         size_t width,
  30                         size_t height,
  31                         const std::string &title,
  32                         Color color,
  33                         Border border)
  34                         : Window(startx, starty, width, height, title, color, border),
  35                         itsBeginning(0),
  36                         itsFoundForEach(0),
  37                         itsFoundValueBegin(-1),
  38                         itsFoundValueEnd(-1),
  39                         itsRealHeight(1)
  40 {
  41 }
  42
  43 Scrollpad::Scrollpad(const Scrollpad &s) : Window(s)
  44 {
  45         itsBuffer << s.itsBuffer;
  46         itsBeginning = s.itsBeginning;
  47         itsRealHeight = s.itsRealHeight;
  48 }
  49
  50 void Scrollpad::Flush()
  51 {
  52         itsRealHeight = 1;
  53
  54         std::basic_string<my_char_t> s = itsBuffer.Str();
  55
  56         size_t x = 0;
  57         int x_pos = 0;
  58         int space_pos = 0;
  59
  60         for (size_t i = 0; i < s.length(); ++i)
  61         {
  62                 x += s[i] != '\t' ? wcwidth(s[i]) : 8-x%8; // tab size
  63
  64                 if (s[i] == ' ') // if space, remember its position;
  65                 {
  66                         space_pos = i;
  67                         x_pos = x;
  68                 }
  69
  70                 if (x >= itsWidth)
  71                 {
  72                         // if line is over, there was at least one space in this line and we are in the middle of the word, restore position to last known space and make it EOL
  73                         if (space_pos > 0 && (s[i] != ' ' || s[i+1] != ' '))
  74                         {
  75                                 i = space_pos;
  76                                 x = x_pos;
  77                                 s[i] = '\n';
  78                         }
  79                 }
  80
  81                 if (x >= itsWidth || s[i] == '\n')
  82                 {
  83                         itsRealHeight++;
  84                         x = 0;
  85                         space_pos = 0;
  86                 }
  87         }
  88         itsRealHeight = std::max(itsHeight, itsRealHeight);
  89         Recreate(itsWidth, itsRealHeight);
  90         itsBuffer.SetTemp(&s);
  91         static_cast<Window &>(*this) << itsBuffer;
  92         itsBuffer.SetTemp(0);
  93 }
  94
  95 bool Scrollpad::SetFormatting(short val_b, const std::basic_string<my_char_t> &s, short val_e, bool for_each)
  96 {
  97         bool result = itsBuffer.SetFormatting(val_b, s, val_e, for_each);
  98         if (result)
  99         {
 100                 itsFoundForEach = for_each;
 101                 itsFoundValueBegin = val_b;
 102                 itsFoundValueEnd = val_e;
 103                 itsFoundPattern = s;
 104         }
 105         else
 106                 ForgetFormatting();
 107         return result;
 108 }
 109
 110 void Scrollpad::ForgetFormatting()
 111 {
 112         itsFoundForEach = 0;
 113         itsFoundValueBegin = -1;
 114         itsFoundValueEnd = -1;
 115         itsFoundPattern.clear();
 116 }
 117
 118 void Scrollpad::RemoveFormatting()
 119 {
 120         if (itsFoundValueBegin >= 0 && itsFoundValueEnd >= 0)
 121                 itsBuffer.RemoveFormatting(itsFoundValueBegin, itsFoundPattern, itsFoundValueEnd, itsFoundForEach);
 122 }
 123
 124 void Scrollpad::Refresh()
 125 {
 126         int MaxBeginning = itsRealHeight-itsHeight;
 127         assert(MaxBeginning >= 0);
 128         if (itsBeginning > MaxBeginning)
 129                 itsBeginning = MaxBeginning;
 130         prefresh(itsWindow, itsBeginning, 0, itsStartY, itsStartX, itsStartY+itsHeight-1, itsStartX+itsWidth-1);
 131 }
 132
 133 void Scrollpad::Resize(size_t new_width, size_t new_height)
 134 {
 135         AdjustDimensions(new_width, new_height);
 136         Flush();
 137 }
 138
 139 void Scrollpad::Scroll(Where where)
 140 {
 141         int MaxBeginning = /*itsContent.size() < itsHeight ? 0 : */itsRealHeight-itsHeight;
 142
 143         switch (where)
 144         {
 145                 case wUp:
 146                 {
 147                         if (itsBeginning > 0)
 148                                 itsBeginning--;
 149                         break;
 150                 }
 151                 case wDown:
 152                 {
 153                         if (itsBeginning < MaxBeginning)
 154                                 itsBeginning++;
 155                         break;
 156                 }
 157                 case wPageUp:
 158                 {
 159                         itsBeginning -= itsHeight;
 160                         if (itsBeginning < 0)
 161                                 itsBeginning = 0;
 162                         break;
 163                 }
 164                 case wPageDown:
 165                 {
 166                         itsBeginning += itsHeight;
 167                         if (itsBeginning > MaxBeginning)
 168                                 itsBeginning = MaxBeginning;
 169                         break;
 170                 }
 171                 case wHome:
 172                 {
 173                         itsBeginning = 0;
 174                         break;
 175                 }
 176                 case wEnd:
 177                 {
 178                         itsBeginning = MaxBeginning;
 179                         break;
 180                 }
 181         }
 182 }
 183
 184 void Scrollpad::Clear(bool clear_screen)
 185 {
 186         itsRealHeight = itsHeight;
 187         itsBuffer.Clear();
 188         wclear(itsWindow);
 189         delwin(itsWindow);
 190         itsWindow = newpad(itsHeight, itsWidth);
 191         SetTimeout(itsWindowTimeout);
 192         SetColor(itsColor, itsBgColor);
 193         ForgetFormatting();
 194         keypad(itsWindow, 1);
 195         if (clear_screen)
 196                 Refresh();
 197 }
 198
 199 void Scrollpad::Reset()
 200 {
 201         itsBeginning = 0;
 202 }
 203
 204 #ifdef _UTF8
 205 Scrollpad &Scrollpad::operator<<(const std::string &s)
 206 {
 207         itsBuffer << ToWString(s);
 208         return *this;
 209 }
 210 #endif // _UTF8
 211