kdbg/textvw.cpp

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #include <qpainter.h>
   7 #include <qkeycode.h>
   8 #include "textvw.h"
   9 #include "textvw.moc"
  10 #ifdef HAVE_CONFIG_H
  11 #include "config.h"
  12 #endif
  13 #include "mydebug.h"
  14 #include <iterator>
  15
  16 #define DEFAULT_WIDTH 100
  17 #define DEFAULT_LINEHEIGHT 1
  18
  19 KTextView::KTextView(QWidget* parent, const char* name, WFlags f) :
  20         TableView(parent, name, f),
  21         m_width(DEFAULT_WIDTH),
  22         m_height(DEFAULT_LINEHEIGHT),
  23         m_tabWidth(0),
  24         m_curRow(-1)
  25 {
  26     setNumCols(1);
  27     setBackgroundColor(colorGroup().base());
  28 }
  29
  30 KTextView::~KTextView()
  31 {
  32 }
  33
  34 /*
  35  * Update cell width and hight; returns whether there is a change
  36  * Cell geometry: There are 2 pixels to the left and to the right
  37  * and 1 pixel _below_ the line
  38  */
  39 bool KTextView::updateCellSize(const QString& text)
  40 {
  41     QPainter p(this);
  42     setupPainter(&p);
  43     QRect r = p.boundingRect(0,0, 0,0,
  44                              AlignLeft | SingleLine | DontClip | ExpandTabs,
  45                              text, text.length());
  46
  47     bool update = false;
  48     int w = r.width() + 4;
  49     if (w > m_width) {
  50         m_width = w;
  51         update = true;
  52     }
  53     int h = r.height() + 1;
  54     if (h > m_height) {
  55         m_height = h;
  56         update = true;
  57     }
  58     return update;
  59 }
  60
  61 void KTextView::setText(const QString& text)
  62 {
  63     QStringList l = QStringList::split('\n', text, true);
  64
  65     bool autoU = autoUpdate();
  66     setAutoUpdate(false);
  67
  68     int lineNo = QMIN(m_texts.size(), l.size());
  69     for (int i = 0; i < lineNo; i++) {
  70         replaceLine(i, l[i]);
  71     }
  72     if (l.size() > m_texts.size()) {
  73         // the new text has more lines than the old one
  74         // here lineNo is the number of lines of the old text
  75         for (size_t i = lineNo; i < l.size(); i++) {
  76             insertLine(l[i]);
  77         }
  78     } else {
  79         // the new file has fewer lines
  80         // here lineNo is the number of lines of the new file
  81         // remove the excessive lines
  82         m_texts.resize(lineNo);
  83         setNumRows(lineNo);
  84     }
  85
  86     setAutoUpdate(autoU);
  87     if (autoU) {
  88         updateTableSize();
  89         update();
  90     }
  91
  92     // if the cursor is in the deleted lines, move it to the last line
  93     if (m_curRow >= int(m_texts.size())) {
  94         m_curRow = -1;                  /* at this point don't have an active row */
  95         activateLine(m_texts.size()-1); /* now we have */
  96     }
  97 }
  98
  99 void KTextView::insertLine(const QString& text)
 100 {
 101     m_texts.push_back(text);
 102     setNumRows(m_texts.size());
 103
 104     updateCellSize(text);
 105
 106     if (autoUpdate()) {
 107         updateTableSize();
 108         repaint();
 109     }
 110 }
 111
 112 /*
 113  * TODO: This function doesn't shrink the line length if the longest line
 114  * is replaced by a shorter one.
 115  */
 116 void KTextView::replaceLine(int line, const QString& text)
 117 {
 118     if (line < 0 || line >= int(m_texts.size()))
 119         return;
 120
 121     m_texts[line] = text;
 122
 123     bool update = updateCellSize(text);
 124
 125     if (autoUpdate()) {
 126         if (update) {
 127             updateTableSize();
 128         }
 129         repaint();
 130     }
 131 }
 132
 133 void KTextView::insertParagraph(const QString& text, int row)
 134 {
 135     m_texts.insert(m_texts.begin()+row, text);
 136
 137     // update line widths
 138     updateCellSize(text);
 139
 140     setNumRows(m_texts.size());
 141
 142     if (autoUpdate() && isVisible()) {
 143         updateTableSize();
 144         update();
 145     }
 146 }
 147
 148 void KTextView::removeParagraph(int row)
 149 {
 150     m_texts.erase(m_texts.begin()+row);
 151     setNumRows(m_texts.size());
 152
 153     if (autoUpdate() && isVisible()) {
 154         updateTableSize();
 155         update();
 156     }
 157 }
 158
 159 void KTextView::setCursorPosition(int row, int)
 160 {
 161     activateLine(row);
 162 }
 163
 164 void KTextView::cursorPosition(int* row, int* col)
 165 {
 166     *row = m_curRow;
 167     *col = 0;
 168 }
 169
 170 int KTextView::cellWidth(int /*col*/) const
 171 {
 172     return m_width;
 173 }
 174
 175 int KTextView::cellHeight(int /*row*/) const
 176 {
 177     return m_height;
 178 }
 179
 180 int KTextView::textCol() const
 181 {
 182     // by default, the text is in column 0
 183     return 0;
 184 }
 185
 186 void KTextView::paintCell(QPainter* p, int row, int /*col*/)
 187 {
 188     if (row >= int(m_texts.size())) {
 189         return;
 190     }
 191     if (row == m_curRow) {
 192         // paint background
 193         p->fillRect(0,0, m_width,m_height, QBrush(colorGroup().background()));
 194     }
 195     const QString& text = m_texts[row];
 196     p->drawText(2,0, m_width-4, m_height,
 197                 AlignLeft | SingleLine | DontClip | ExpandTabs,
 198                 text, text.length());
 199 }
 200
 201 void KTextView::keyPressEvent(QKeyEvent* ev)
 202 {
 203     int oldRow = m_curRow;
 204
 205     // go to line 0 if no current line
 206     if (m_curRow < 0) {
 207         activateLine(0);
 208     }
 209     else
 210     {
 211         int numVisibleRows, newRow, newX;
 212
 213         switch (ev->key()) {
 214         case Key_Up:
 215             if (m_curRow > 0) {
 216                 activateLine(m_curRow-1);
 217             }
 218             break;
 219         case Key_Down:
 220             if (m_curRow < numRows()-1) {
 221                 activateLine(m_curRow+1);
 222             }
 223             break;
 224         case Key_PageUp:
 225             /* this method doesn't work for variable height lines */
 226             numVisibleRows = lastRowVisible()-topCell();
 227             newRow = m_curRow - QMAX(numVisibleRows,1);
 228             if (newRow < 0)
 229                 newRow = 0;
 230             activateLine(newRow);
 231             break;
 232         case Key_PageDown:
 233             /* this method doesn't work for variable height lines */
 234             numVisibleRows = lastRowVisible()-topCell();
 235             newRow = m_curRow + QMAX(numVisibleRows,1);
 236             if (newRow >= numRows())
 237                 newRow = numRows()-1;
 238             activateLine(newRow);
 239             break;
 240
 241         // scroll left and right by a few pixels
 242         case Key_Left:
 243             newX = xOffset() - viewWidth()/10;
 244             setXOffset(QMAX(newX, 0));
 245             break;
 246         case Key_Right:
 247             newX = xOffset() + viewWidth()/10;
 248             setXOffset(QMIN(newX, maxXOffset()));
 249             break;
 250
 251         default:
 252             QWidget::keyPressEvent(ev);
 253             return;
 254         }
 255     }
 256     // make row visible
 257     if (m_curRow != oldRow && !rowIsVisible(m_curRow)) {
 258         // if the old row was visible, we scroll the view by some pixels
 259         // if the old row was not visible, we place active row at the top
 260         if (oldRow >= 0 && rowIsVisible(oldRow)) {
 261             int diff = m_curRow - oldRow;
 262             int newTop = topCell() + diff;
 263             setTopCell(QMAX(newTop,0));
 264         } else {
 265             setTopCell(m_curRow);
 266         }
 267     }
 268     ev->accept();
 269 }
 270
 271 void KTextView::mousePressEvent(QMouseEvent* ev)
 272 {
 273     int row = findRow(ev->y());
 274     activateLine(row);
 275 }
 276
 277 void KTextView::focusInEvent(QFocusEvent*)
 278 {
 279     /*
 280      * The base class does a repaint(), which causes flicker. So we do
 281      * nothing here.
 282      */
 283 }
 284
 285 void KTextView::focusOutEvent(QFocusEvent*)
 286 {
 287     /*
 288      * The base class does a repaint(), which causes flicker. So we do
 289      * nothing here.
 290      */
 291 }
 292
 293 void KTextView::activateLine(int row)
 294 {
 295     if (row == m_curRow)
 296         return;
 297
 298     int col = textCol();
 299
 300     int oldRow = m_curRow;
 301     // note that row may be < 0
 302     m_curRow = row;
 303     // must change m_curRow first, so that updateCell(oldRow) erases the old line!
 304     if (oldRow >= 0) {
 305         updateCell(oldRow, col);
 306     }
 307     if (row >= 0) {
 308         updateCell(row, col);
 309     }
 310     emit lineChanged();
 311 }
 312
 313 /* This is needed to make the kcontrol's color setup working */
 314 void KTextView::paletteChange(const QPalette& oldPal)
 315 {
 316     setBackgroundColor(colorGroup().base());
 317     TableView::paletteChange(oldPal);
 318
 319     // recompute window size
 320     m_width = DEFAULT_WIDTH;
 321     m_height = DEFAULT_LINEHEIGHT;
 322     for (size_t i = 0; i < m_texts.size(); i++) {
 323         updateCellSize(m_texts[i]);
 324     }
 325     updateTableSize();
 326 }
 327
 328 void KTextView::setTabWidth(int numChars)
 329 {
 330     QFontMetrics fm = font();
 331     int newTabWidth = fm.width('x') * numChars;
 332     if (newTabWidth == m_tabWidth)
 333         return;
 334     m_tabWidth = newTabWidth;
 335
 336     // recompute window width
 337     m_width = DEFAULT_WIDTH;
 338     for (size_t i = 0; i < m_texts.size(); i++) {
 339         updateCellSize(m_texts[i]);
 340     }
 341
 342     updateTableSize();
 343     if (autoUpdate()) {
 344         repaint();
 345     }
 346 }
 347
 348 void KTextView::setupPainter(QPainter* p)
 349 {
 350     p->setTabStops(m_tabWidth);
 351 }
 352
 353 int KTextView::charAt(const QPoint& p, int* para)
 354 {
 355     if (findCol(p.x()) != textCol())
 356         return *para = -1;
 357     int row = findRow(p.y());
 358     *para = row;
 359     if (row < 0)
 360         return -1;
 361
 362     // find top-left corner of text cell
 363     int top, left;
 364     if (!colXPos(textCol(), &left))
 365         return -1;
 366     if (!rowYPos(row, &top))
 367         return -1;
 368
 369     // get the bounding rect of the text
 370     QPainter painter(this);
 371     setupPainter(&painter);
 372     const QString& text = m_texts[row];
 373     QRect bound =
 374         painter.boundingRect(left+2, top, 0,0,
 375                              AlignLeft | SingleLine | DontClip | ExpandTabs,
 376                              text, text.length());
 377     if (!bound.contains(p))
 378         return -1;                      /* p is outside text */
 379
 380     for (uint n = 0; n < text.length(); n++)
 381     {
 382         /*
 383          * If p is in the rectangle that has n+1 characters, than n
 384          * is the character we are looking for
 385          */
 386         bound =
 387             painter.boundingRect(left+2, top, 0,0,
 388                                  AlignLeft | SingleLine | DontClip | ExpandTabs,
 389                                  text, n+1);
 390         if (bound.contains(p))
 391             return n;
 392     }
 393     return -1;
 394 }