khtml_caret_p.h

Go to the documentation of this file.

/* This file is part of the KDE project
 *
 * Copyright (C) 2003-2004 Leo Savernik <l.savernik@aon.at>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#ifndef KHTML_CARET_P_H
#define KHTML_CARET_P_H

#include "rendering/render_table.h"


#define DEBUG_CARETMODE 0

class QFontMetrics;

namespace DOM {
  class NodeImpl;
  class ElementImpl;
}

namespace khtml {

enum CaretAdvancePolicy {
    LeafsOnly, IndicatedFlows, VisibleFlows
};

struct CaretViewContext {
    int freqTimerId;        // caret blink frequency timer id
    int x, y;           // caret position in viewport coordinates
                    // (y specifies the top, not the baseline)
    int width;          // width of caret in pixels
    int height;         // height of caret in pixels
    bool visible;       // true if currently visible.
    bool displayed;     // true if caret is to be displayed at all.
    bool caretMoved;        // set to true once caret has been moved in page
                    // how to display the caret when view is not focused
    KHTMLPart::CaretDisplayPolicy displayNonFocused;

    int origX;

    bool keyReleasePending; // true if keypress under caret mode awaits
                    // corresponding release event
    CaretViewContext() : freqTimerId(-1), x(0), y(0), width(1), height(16),
        visible(true), displayed(false), caretMoved(false),
    displayNonFocused(KHTMLPart::CaretInvisible), origX(0),
    keyReleasePending(false)
    {}
};

class LinearDocument;

template<class T> class MassDeleter : public QVector<T *> {
public:
  MassDeleter(size_t reserved = 1) { this->reserve(reserved); }
  ~MassDeleter()
  {
    typename QVector<T *>::Iterator nd = this->end();
    for (typename QVector<T *>::Iterator it = this->begin(); it != nd; ++it)
      delete *it;
  }
};

class CaretBoxLine;

class CaretBox {
protected:
  InlineBox *_box;      // associated inline box if available.
  short _w;         // width of box in pixels
  int _h;           // height of box in pixels
  int _x;           // x coordinate relative to containing block
  int _y;           // y coordinate relative to containing block
  RenderBox *cb;        // containing block
  bool _outside:1;      // true when representing the outside of the element
  bool outside_end:1;       // at ending outside of element rather than at beginning
  // 29 bits unused

public:
  CaretBox() {}
  CaretBox(InlineBox *ibox, bool outside, bool outsideEnd) : _box(ibox),
    _w((short)ibox->width()), _h(ibox->height()), _x(ibox->xPos()),
        _y(ibox->yPos()), cb(0), _outside(outside), outside_end(outsideEnd)
  {
    RenderObject *r = ibox->object();
    if (r) cb = r->containingBlock();
  }
  CaretBox(int x, int y, int w, int h, RenderBox *cb, bool outside, bool outsideEnd) :
         _box(0), _w((short)w), _h(h), _x(x), _y(y), cb(cb), _outside(outside),
         outside_end(outsideEnd)
  {}

  int width() const { return _w; }
  int height() const { return _h; }
  int xPos() const { return _x; }
  int yPos() const { return _y; }
  RenderBox *enclosingObject() const { return cb; }
  InlineBox *inlineBox() const { return _box; }

  RenderBlock *containingBlock() const { return _box ? static_cast<RenderBlock *>(cb) : cb->containingBlock(); }

  bool isInline() const { return _box; }
  bool isInlineTextBox() const { return _box && _box->isInlineTextBox(); }
  bool isLineBreak() const
  {
    return _box && _box->object() && _box->object()->isBR();
  }
  bool isOutside() const { return _outside; }
  bool isOutsideEnd() const { return outside_end; }
  RenderObject *object() const { return _box ? _box->object() : cb; }

  long minOffset() const { return _box && !isLineBreak() ? _box->minOffset() : 0; }
  long maxOffset() const { return _box && !isLineBreak() ? _box->maxOffset() : 0; }

#if DEBUG_CARETMODE > 0
  void dump(QTextStream &ts, const QString &ind) const;
#endif

  friend class CaretBoxLine;
};

typedef MassDeleter<CaretBox> CaretBoxDeleter;

class CaretBoxIterator {
protected:
  CaretBoxLine *cbl;        // associated caret box line
  int index;            // current index

public:
  // Let standard constructor/copy constructor/destructor/assignment operator
  // be defined by the compiler. They do exactly what we want.
  CaretBoxIterator()
    : cbl( 0 ), index( 0 )
  {
  }

  bool operator ==(const CaretBoxIterator &it) const
  {
    return cbl == it.cbl && index == it.index;
  }

  bool operator !=(const CaretBoxIterator &it) const
  {
    return !operator ==(it);
  }

  CaretBox *data() const;
  CaretBox *operator *() const { return data(); }

  CaretBoxIterator &operator ++() { index++; return *this; }
  CaretBoxIterator &operator --() { index--; return *this; }

  friend class CaretBoxLine;
  friend class EditableCaretBoxIterator;
};

class CaretBoxLine {
protected:
  CaretBoxDeleter caret_boxes;
  // base flow box which caret boxes have been constructed for
  InlineFlowBox *basefb;

  CaretBoxLine() : caret_boxes(8), basefb(0) {}
  CaretBoxLine(InlineFlowBox *basefb) : caret_boxes(8), basefb(basefb) {}
public:
#if DEBUG_CARETMODE > 3
  ~CaretBoxLine() { kDebug(6200) << "called"; }
#endif

  CaretBoxIterator begin()
  {
    CaretBoxIterator it;
    it.cbl = this;
    it.index = 0;
    return it;
  }
  CaretBoxIterator end()
  {
    CaretBoxIterator it;
    it.cbl = this;
    it.index = caret_boxes.size();
    return it;
  }
  CaretBoxIterator preBegin()
  {
    CaretBoxIterator it;
    it.cbl = this;
    it.index = -1;
    return it;
  }
  CaretBoxIterator preEnd()
  {
    CaretBoxIterator it;
    it.cbl = this;
    it.index = caret_boxes.size() - 1;
    return it;
  }

  InlineFlowBox *baseFlowBox() const { return basefb; }

  RenderBlock *containingBlock() const { return caret_boxes[0]->containingBlock(); }
  RenderBox *enclosingObject() const { return caret_boxes[0]->enclosingObject(); }

  bool isOutside() const
  {
    const CaretBox *cbox = caret_boxes[0];
    return !cbox->isInline() && cbox->isOutside();
  }

  bool isOutsideEnd() const { return caret_boxes[0]->isOutsideEnd(); }

  static CaretBoxLine *constructCaretBoxLine(MassDeleter<CaretBoxLine> *deleter,
    InlineFlowBox *baseFlowBox, InlineBox *seekBox, bool seekOutside,
        bool seekOutsideEnd, CaretBoxIterator &iter,
    RenderObject *seekObject = 0) /*KDE_NO_EXPORT*/;

  static CaretBoxLine *constructCaretBoxLine(MassDeleter<CaretBoxLine> *deleter,
    RenderBox *cb, bool outside, bool outsideEnd, CaretBoxIterator &iter) /*KDE_NO_EXPORT*/;

#if DEBUG_CARETMODE > 0
  void dump(QTextStream &ts, const QString &ind) const;
  QString information() const
  {
    QString result;
    QTextStream ts(&result, QIODevice::WriteOnly);
    dump(ts, QString());
    return result;
  }
#endif

protected:
  struct SeekBoxParams {
    InlineBox *box;
    bool outside;
    bool outsideEnd;
    bool found;
    RenderObject *r;    // if box is 0, seek for equal render objects instead
    CaretBoxIterator &it;

    SeekBoxParams(InlineBox *box, bool outside, bool outsideEnd, RenderObject *obj, CaretBoxIterator &it)
        : box(box), outside(outside), outsideEnd(outsideEnd), found(false), r(obj), it(it)
    {}

    bool equalsBox(const InlineBox *box, bool outside, bool outsideEnd) const
    {
      return (this->box && this->box == box
              || this->r == box->object())
          && this->outside == outside
          && (!this->outside || this->outsideEnd == outsideEnd);
    }
    bool operator ==(const CaretBox *cbox) const
    {
      return equalsBox(cbox->inlineBox(), cbox->isOutside(), cbox->isOutsideEnd());
    }
    bool check(const CaretBoxIterator &chit)
    {
      if (*this == *chit) {
        Q_ASSERT(!found);
        found = true;
        it = chit;
      }
      return found;
    }
  };

  void addConvertedInlineBox(InlineBox *, SeekBoxParams &) /*KDE_NO_EXPORT*/;

  void addCreatedInlineBoxEdge(InlineBox *box, const QFontMetrics &fm,
    bool left, bool rtl) /*KDE_NO_EXPORT*/;
  void addCreatedFlowBoxEdge(InlineFlowBox *flowBox, const QFontMetrics &fm,
    bool left, bool rtl) /*KDE_NO_EXPORT*/;
  void addCreatedFlowBoxInside(InlineFlowBox *flowBox, const QFontMetrics &fm) /*KDE_NO_EXPORT*/;

  friend class CaretBoxIterator;
};

typedef MassDeleter<CaretBoxLine> CaretBoxLineDeleter;

inline CaretBox *CaretBoxIterator::data() const { return cbl->caret_boxes[index]; }

class LineIterator
{
protected:
  LinearDocument *lines;    // associated document
  CaretBoxLine *cbl;        // current caret box line

  static CaretBoxIterator currentBox;   // current inline box
  static long currentOffset;

  // Note: cbl == 0 indicates a position beyond the beginning or the
  // end of a document.

  LineIterator() {}

  LineIterator(LinearDocument *l, DOM::NodeImpl *node, long offset);

public:
  CaretBoxLine *operator *() const { return cbl; }

  LinearDocument *linearDocument() const { return lines; }

  LineIterator &operator ++() { advance(false); return *this; }

  LineIterator &operator --() { advance(true); return *this; }

  bool operator ==(const LineIterator &it) const
  {
    return lines == it.lines && cbl == it.cbl;
  }

  bool operator !=(const LineIterator &it) const
  {
    return !operator ==(it);
  }

  bool isOutsideEnd() { return cbl->isOutsideEnd(); }

  bool isOutside() const { return cbl->isOutside(); }

  void advance(bool toBegin);

  static CaretBoxIterator &currentCaretBox() { return currentBox; }

  static long currentModifiedOffset() { return currentOffset; }

protected:
  void nextBlock();
  void prevBlock();

  friend class CaretBoxIterator;
  friend class EditableLineIterator;
  friend class EditableCaretBoxIterator;
  friend class EditableCharacterIterator;
  friend class LinearDocument;
};

class LinearDocument {
public:
  typedef LineIterator Iterator;

  LinearDocument(KHTMLPart *part, DOM::NodeImpl *node, long offset,
        CaretAdvancePolicy advancePolicy, DOM::ElementImpl *baseElem);

  virtual ~LinearDocument();

  bool isValid() const      // FIXME: not yet impl'd
  {
    return true;
  }

  int count() const;

  Iterator current();

  const Iterator &end() const { return _end; }

  Iterator preEnd();

  Iterator begin();

  const Iterator &preBegin() const { return _preBegin; }

  CaretAdvancePolicy advancePolicy() const { return advPol; }

  RenderObject *baseObject() const { return base; }

protected:
  void initPreBeginIterator();
  void initEndIterator();

protected:
  CaretBoxLineDeleter cblDeleter;   // mass deleter for caret box lines
  DOM::NodeImpl *node;
  long offset;

  Iterator _preBegin;
  Iterator _end;

  KHTMLPart *m_part;
  CaretAdvancePolicy advPol;
  RenderObject *base;

  friend class LineIterator;
  friend class EditableLineIterator;
  friend class ErgonomicEditableLineIterator;
  friend class CaretBoxIterator;
  friend class EditableCaretBoxIterator;
  friend class EditableCharacterIterator;
};

class EditableCaretBoxIterator : public CaretBoxIterator {
  KHTMLPart *m_part;
  bool adjacent;
  CaretAdvancePolicy advpol;    // caret advance policy

public:
  EditableCaretBoxIterator(LineIterator &lit, bool fromEnd = false,
        CaretBoxIterator *it = 0)
        : CaretBoxIterator(it ? *it : (fromEnd ? (*lit)->end() : (*lit)->preBegin())),
                m_part(lit.lines->m_part), adjacent(false),
                advpol(lit.lines->advancePolicy())
  {
    if (!it) {
      if (fromEnd) --*this; else ++*this;
    }
  }

  EditableCaretBoxIterator() {}

  bool isAdjacent() const { return adjacent; }

  EditableCaretBoxIterator &operator ++() { advance(false); return *this; }

  EditableCaretBoxIterator &operator --() { advance(true); return *this; }

  void advance(bool toBegin);

protected:
  bool isEditable(const CaretBoxIterator &boxit, bool fromEnd);
};

class EditableLineIterator : public LineIterator {
public:
  EditableLineIterator(const LineIterator &it, bool fromEnd = false)
        : LineIterator(it)
  {
    if (!cbl) return;
    if (!isEditable(*this)) advance(fromEnd);
  }

  EditableLineIterator() {}

  EditableLineIterator &operator ++() { advance(false); return *this; }

  EditableLineIterator &operator --() { advance(true); return *this; }

  void advance(bool toBegin);

protected:
  bool isEditable(LineIterator &it)
  {
    EditableCaretBoxIterator fbit = it;
    return fbit != (*it)->end();
  }

};

class TableRowIterator {
protected:
  TableSectionIterator sec; // current section
  int index;            // index of row within section
public:
  TableRowIterator(RenderTable *table, bool fromEnd = false,
        RenderTableSection::RowStruct *row = 0);

  TableRowIterator(RenderTableSection *section, int index)
    : sec(section), index(index)
  {}

  TableRowIterator() {}

  RenderTableSection::RowStruct *operator *()
  {
    if (!*sec) return 0;
    return &(*sec)->grid[index];
  }

  TableRowIterator &operator ++();

  TableRowIterator &operator --();

protected:
};

class ErgonomicEditableLineIterator : public EditableLineIterator {
protected:
  int xCoor;        // x-coordinate to determine cell position
public:
  ErgonomicEditableLineIterator(const LineIterator &it, int x)
    : EditableLineIterator(it), xCoor(x) {}

  ErgonomicEditableLineIterator() {}

  ErgonomicEditableLineIterator &operator ++();

  ErgonomicEditableLineIterator &operator --();

protected:
  void determineTopologicalElement(RenderTableCell *oldCell,
        RenderObject *newObject, bool toBegin);

  void calcAndStoreNewLine(RenderBlock *newBlock, bool toBegin);

};

class EditableCharacterIterator {
protected:
  EditableLineIterator _it;
  EditableCaretBoxIterator ebit;
  long _offset;     // offset within current caret box.
  int _char;
  bool _end:1;      // true when end of document has been reached

public:

  EditableCharacterIterator() {}

  EditableCharacterIterator(LinearDocument *ld)
        : _it(ld->current()),
                ebit(_it, false, &_it.currentCaretBox()),
            _offset(_it.currentModifiedOffset()), _char(-1), _end(false)
  {
    // ### temporary fix for illegal nodes
    if (_it == ld->end()) { _end = true; return; }
    initFirstChar();
  }

  int chr() const { return _char; }

  QChar operator *() const { return QChar(_char >= 0 ? _char : ' '); }

  bool isEnd() const { return _end; }
  long offset() const { return _offset; }
  RenderObject *renderer() const { return (*ebit)->object(); }
  CaretBox *caretBox() const { return *ebit; }
  InlineBox *inlineBox() const { return (*ebit)->inlineBox(); }
//  bool boxIsOutside() const { return _it.isOutside(); }

  EditableCharacterIterator &operator ++();

  EditableCharacterIterator &operator --();

protected:
  void initFirstChar();
  void peekNext()
  {
    EditableCaretBoxIterator copy = ebit;
    ++copy;
    if (copy == (*_it)->end()) { _char = -1; return; }

    CaretBox *box = *copy;
    InlineBox *b = box->inlineBox();
    if (b && !box->isOutside() && b->isInlineTextBox())
      _char = static_cast<RenderText *>(b->object())->str->s[b->minOffset()].unicode();
    else
      _char = -1;
  }
  void peekPrev()
  {
    --ebit;
  }

};


}/*namespace khtml*/


#endif