CDrawBuffer.cpp

Go to the documentation of this file.

#include "CDrawBuffer.h"
#include "FontControl.h"
#include <qfontmetrics.h>
#include <qpainter.h>
#include <qpixmap.h>
#include <qimage.h>

CDrawBuffer::~CDrawBuffer()
{
    while (!segs.isEmpty()) segs.erase(0);
}

void CDrawBuffer::setright(CDrawBuffer& rhs, int f)
{
  int i;
  len = rhs.len;
  fc = rhs.fc;
  m_ascent = m_descent = m_lineSpacing = m_lineExtraSpacing = 0;
  while (!segs.isEmpty())
  {
      segs.erase(0);
  }
  for (CList<textsegment>::iterator iter = rhs.segs.begin(); iter != rhs.segs.end(); )
  {
      CList<textsegment>::iterator next = iter;
      iter++;
      if (iter == rhs.segs.end() || iter->start > f)
      {
          int st = next->start-f;
          if (st < 0) st = 0;

          CStyle _style = next->style;
          segs.push_back(textsegment(st,next->style));
      }
  }
  for (i = f; rhs[i] != '\0'; i++) (*this)[i-f] = rhs[i];
  (*this)[i-f] = '\0';
  len = i;
}

CDrawBuffer& CDrawBuffer::operator=(CDrawBuffer& rhs)
{
  int i;
//  //qDebug("Trying 2");
  len = rhs.len;
  m_ascent = rhs.m_ascent;
  m_descent = rhs.m_descent;
  m_lineSpacing = rhs.m_lineSpacing;
  m_lineExtraSpacing = rhs.m_lineExtraSpacing;
  m_showPartial = rhs.m_showPartial;
  while (!segs.isEmpty())
  {
      segs.erase(0);
  }
  for (CList<textsegment>::iterator iter = rhs.segs.begin(); iter != rhs.segs.end(); iter++)
  {
      segs.push_back(*iter);
  }
  for (i = 0; rhs[i] != '\0'; i++) (*this)[i] = rhs[i];
  (*this)[i] = '\0';
  len = i;
//  //qDebug("Tried 2");
  return *this;
}

CDrawBuffer& CDrawBuffer::operator=(const tchar*sztmp)
{
  int i;
  while (!segs.isEmpty())
  {
      segs.erase(0);
  }
  segs.push_back(textsegment(0, CStyle()));
  for (i = 0; sztmp[i] != '\0'; i++) (*this)[i] = sztmp[i];
  (*this)[i] = '\0';
  len = i;
  return *this;
}

void CDrawBuffer::empty()
{
    m_bSop = false;
    m_bEop = false;
    m_bBop = false;
    len = 0;
    (*this)[0] = 0;
    while (!segs.isEmpty())
    {
        segs.erase(0);
    }
    segs.push_back(textsegment(0,CStyle()));
    m_ascent = m_descent = m_lineSpacing = m_lineExtraSpacing = 0;
    m_bEof = false;
}

void CDrawBuffer::setendpara(const CStyle& _style/* = ucFontBase*/)
{
   m_bEop = true;
   if (len == 0)
    {
        segs.first().start = 0;
        segs.first().style = _style;
    }
}

void CDrawBuffer::addch(tchar ch, CStyle _style/* = ucFontBase*/)
{
    if (len == 0)
    {
        segs.first().start = 0;
        segs.first().style = _style;
    }
    else if (_style != segs.last().style)
    {
        segs.push_back(textsegment(len, _style));
    }
    (*this)[len++] = ch;
}

void CDrawBuffer::truncate(int n)
{
    len = n;
    (*this)[n] = 0;
}

int CDrawBuffer::width(int availht, int numchars, bool onscreen, int scwidth, unsigned short _lborder, unsigned short _rborder)
{
    int gzoom = fc->gzoom();
    int currentx = 0, end = 0;
    QString text = (numchars < 0) ? toQString(data()) : toQString(data(), numchars);
    CList<textsegment>::iterator textstart = segs.begin();
    int extraspace = 0;
    bool just = (onscreen && !m_bEop && textstart->style.getJustify() == m_AlignJustify);
    int spaces = 0;
    int spacesofar = 0;
    int spacenumber = 0;
    int nonspace = 0;
    if (just)
    {
        for (int i = 0; i < len; i++)
        {
            if ((*this)[i] != ' ')
            {
                nonspace = i;
                break;
            }
        }
#ifdef _WINDOWS
        for (i = nonspace; i < len; i++)
#else
        for (int i = nonspace; i < len; i++)
#endif
        {
            if ((*this)[i] == ' ')
            {
                spaces++;
            }
        }
        if (spaces == 0)
        {
            just = false;
        }
        else
        {
            extraspace = (scwidth - (_lborder+_rborder) - rightMargin() - leftMargin() - width(availht));
            if (extraspace == 0) just = false;
        }
    }
    CList<textsegment>::iterator textend = textstart;
    do
    {
        textend++;
        end = (textend != segs.end()) ? textend->start : len;
        if (numchars >= 0 && end > numchars)
        {
            end = numchars;
        }
        CStyle currentstyle = textstart->style;
        if (currentstyle.isPicture())
        {
            if (currentstyle.canScale())
            {
              int ht = (gzoom*currentstyle.getPicture()->height())/100;
              int wt = (gzoom*currentstyle.getPicture()->width())/100;
              if (ht > availht)
                {
                  wt = (wt*availht)/ht;
                }
              currentx += wt;
            }
            else
            {
                currentx += currentstyle.getPicture()->width();
            }
        }
        else
        {
            if (currentstyle.isMono() && !fc->hasCourier())
            {
                int cw = (7*fc->getsize(currentstyle))/10;
                currentx += cw*(end-textstart->start);
            }
            else
            {
                QFont f(currentstyle.isMono() ? QString(fc->fixedfontname()) : fc->name(), fc->getsize(currentstyle), (currentstyle.isBold()) ? QFont::Bold : QFont::Normal, (currentstyle.isItalic()) );
//          f.setUnderline(currentstyle.isUnderline());
                QString str = text.mid(textstart->start, end-textstart->start);
                QFontMetrics fm(f);
                if (just)
                {
                    int lastspace = -1;
                    int nsp = 0;
                    int cx = currentx;
                    while ((nsp = str.find(" ", lastspace+1)) >= 0)
                    {
                        if (nsp > nonspace)
                        {
                            spacenumber++;
                            int nexttoadd = (extraspace*spacenumber+spaces/2)/spaces - spacesofar;
                            QString nstr = str.mid(lastspace+1, nsp-lastspace);
                            int lw = fm.width(nstr);
                            cx += lw+nexttoadd;
                            spacesofar += nexttoadd;
                            lastspace = nsp;
                        }
                        else
                        {
                            QString nstr = str.mid(lastspace+1, nsp-lastspace);
//                          qDebug("str:%s: last:%d new:%d nstr:%s:", (const char*)str, lastspace, nsp, (const char*)nstr);
                            int lw = fm.width(nstr);
                            cx += lw;
                            lastspace = nsp;
                        }
                    }
                    QString nstr = str.right(str.length()-1-lastspace);
                    cx += fm.width(nstr);
                    currentx = cx;
                }
                else
                {
                    currentx += fm.width(str);
                }
            }
        }
        textstart = textend;
    }
    while (textend != segs.end() && end != numchars && textstart->start < len);
    return currentx;
}

int CDrawBuffer::charwidth(int numchars, CStyle& currentstyle)
{
    if (currentstyle.isPicture())
      {
        int gzoom = fc->gzoom();
        if (currentstyle.canScale())
          {
            return (gzoom*currentstyle.getPicture()->width())/100;
          }
        else
          {
            return currentstyle.getPicture()->width();
          }
      }
    else
      {
        if (currentstyle.isMono() && !fc->hasCourier())
          {
            return (7*fc->getsize(currentstyle))/10;
          }
        else
          {
            QString text = QChar((data())[numchars]);
            QFont f(currentstyle.isMono() ? QString(fc->fixedfontname()) : fc->name(), fc->getsize(currentstyle), (currentstyle.isBold()) ? QFont::Bold : QFont::Normal, (currentstyle.isItalic()) );
            //      f.setUnderline(currentstyle.isUnderline());
            QFontMetrics fm(f);
            return fm.width(text);
          }
      }
    return 0;
}

int CDrawBuffer::charwidth(int numchars)
{
    int gzoom = fc->gzoom();
    int end = 0;
    QString text = QChar((data())[numchars]);
    CList<textsegment>::iterator textstart = segs.begin();
    CList<textsegment>::iterator textend = textstart;
    do
    {
        textend++;
        end = (textend != segs.end()) ? textend->start : len;
        if (end <= numchars)
        {
            textstart = textend;
            continue;
        }
        if (numchars >= 0 && end > numchars)
        {
            end = numchars;
        }
        CStyle currentstyle = textstart->style;
        if (currentstyle.isPicture())
        {
            if (currentstyle.canScale())
            {
                return (gzoom*currentstyle.getPicture()->width())/100;
            }
            else
            {
                return currentstyle.getPicture()->width();
            }
        }
        else
        {
            if (currentstyle.isMono() && !fc->hasCourier())
            {
                return (7*fc->getsize(currentstyle))/10;
            }
            else
            {
                QFont f(currentstyle.isMono() ? QString(fc->fixedfontname()) : fc->name(), fc->getsize(currentstyle), (currentstyle.isBold()) ? QFont::Bold : QFont::Normal, (currentstyle.isItalic()) );
//          f.setUnderline(currentstyle.isUnderline());
                QFontMetrics fm(f);
                return fm.width(text);
            }
        }
        textstart = textend;
    }
    while (textend != segs.end() /* && end != numchars*/ && textstart->start < len);
    return 0;
}



int CDrawBuffer::leftMargin()
{
    return (segs.begin()->style.getLeftMargin()*fc->getsize(segs.begin()->style)+3)/6;
}

int CDrawBuffer::rightMargin()
{
    return (segs.begin()->style.getRightMargin()*fc->getsize(segs.begin()->style)+3)/6;
}

int CDrawBuffer::offset(int scwidth, unsigned short _lborder, unsigned short _rborder, int availht)
{
    int currentx = _lborder;
    switch(segs.begin()->style.getJustify())
    {
        case m_AlignRight:
        {
            currentx = scwidth - _rborder - rightMargin() - width(availht);
        }
        break;
        case m_AlignCentre:
        {
            currentx = (
                scwidth - _lborder -_rborder +
                leftMargin() - rightMargin()
                - width(availht))/2 + _lborder;
        }
        break;
        case m_AlignJustify:
        case m_AlignLeft:
        case m_AlignNone:
            currentx = _lborder + leftMargin();
            break;
    }
    return currentx;
}

void CDrawBuffer::render(QPainter* _p, int _y, bool _bMono, int _charWidth, int scwidth, unsigned short _lborder, unsigned short _rborder, const QColor& _bg, int availht)
{
    CList<textsegment>::iterator textstart = segs.begin();
   QColor paperColour = QColor(qRgb(textstart->style.pRed(),
                                    textstart->style.pGreen(),
                                    textstart->style.pBlue()));

   Highlight(_p, !(paperColour == _bg), _lborder, _y, scwidth-(_lborder+_rborder), paperColour);
   //   Highlight(_p, true, _lborder, _y, scwidth-(_lborder+_rborder), paperColour);
    int gzoom = fc->gzoom();
    int currentx = offset(scwidth, _lborder, _rborder, availht);
   if (!m_hastext)
     {
        for (CList<textsegment>::iterator iter = segs.begin(); iter != segs.end(); iter++)
          {
             CStyle currentstyle = iter->style;
             if (currentstyle.isPicture())
               {
                  CStyle currentstyle = segs.begin()->style;
                  int ht = (gzoom*currentstyle.getPicture()->height())/100;
                  int wt = (gzoom*currentstyle.getPicture()->width())/100;
                  bool willscale = false;
                  if (ht > availht)
                    {
                      wt = (wt*availht)/ht;
                      ht = availht;
                      willscale = true;
                    }

                  QPixmap pc;
                  if ((willscale || gzoom != 100) && currentstyle.canScale())
                    {
                       QImage im = currentstyle.getPicture()->smoothScale(wt,ht);
                       pc.convertFromImage(im);
                    }
                  else
                    {
                       pc.convertFromImage(*currentstyle.getPicture());
                    }
                  int yoffset = pc.height()/2;
                  _p->drawPixmap( currentx, _y-yoffset, pc );
                  currentx += pc.width();
               }
          }       
        return;
     }
    QString text = toQString(data());
    int extraspace = 0;
    bool just = (!m_bEop && textstart->style.getJustify() == m_AlignJustify);
    int spaces = 0;
    int spacesofar = 0;
    int spacenumber = 0;
    int nonspace = 0;
    if (just)
    {
        for (int i = 0; i < len; i++)
        {
            if ((*this)[i] != ' ')
            {
                nonspace = i;
                break;
            }
        }
#ifdef _WINDOWS
        for (i = nonspace; i < len; i++)
#else
        for (int i = nonspace; i < len; i++)
#endif
        {
            if ((*this)[i] == ' ')
            {
                spaces++;
            }
        }
        if (spaces == 0)
        {
            just = false;
        }
        else
        {
            extraspace = (scwidth - (_lborder+_rborder) - rightMargin() - leftMargin() - width(availht));
            if (extraspace == 0) just = false;
        }
    }
    CList<textsegment>::iterator textend = textstart;

   bool drawBackground = false;
    do
    {
        textend++;
        int end = (textend != segs.end()) ? textend->start : len;
        CStyle currentstyle = textstart->style;
        /*
        bool drawBackground = (
                               currentstyle.bRed() != 255
                               ||
                               currentstyle.bGreen() != 255
                               ||
                               currentstyle.bBlue() != 255
                               );
        */
        QColor bgColour = QColor(qRgb(currentstyle.bRed(),
                                              currentstyle.bGreen(),
                                              currentstyle.bBlue()));
        drawBackground = !(bgColour == _bg);

//       if (drawBackground) qDebug("Drawing background");
       
        QFont f((currentstyle.isMono() && fc->hasCourier()) ? fc->fixedfontname() : fc->name(), fc->getsize(currentstyle), (currentstyle.isBold()) ? QFont::Bold : QFont::Normal, (currentstyle.isItalic()) );
//      f.setUnderline(currentstyle.isUnderline());
//      if (currentstyle.isUnderline()) qDebug("UNDERLINE");
        _p->setFont(f);
        QString str = text.mid(textstart->start, end-textstart->start);
#if defined(OPIE) || !defined(USEQPE)
        _p->setPen(QPen(QColor(currentstyle.Red(), currentstyle.Green(), currentstyle.Blue()), fc->getsize(currentstyle)/10/*0*/));
#else
        _p->setPen(QPen(QColor(currentstyle.Red(), currentstyle.Green(), currentstyle.Blue()), fc->getsize(currentstyle)/10));
#endif
        int voffset = currentstyle.getVOffset()*fc->getsize(currentstyle)/2;

        if (_bMono)
        {

          Highlight(_p, drawBackground, currentx, _y, str.length()*_charWidth, bgColour);
            if (currentstyle.isUnderline())
            {
                _p->drawLine( currentx, _y+voffset, currentx + str.length()*_charWidth, _y+voffset);
            }
            if (currentstyle.isStrikethru())
            {
                int ascent = fc->ascent(currentstyle)/3;
                _p->drawLine( currentx, _y-ascent+voffset, currentx + str.length()*_charWidth, _y-ascent+voffset);
            }
            for (int i = 0; i < str.length(); i++)
            {
                _p->drawText( currentx + i*_charWidth, _y+voffset, QString(str[i]));
            }
            currentx += str.length()*_charWidth;
        }
        else
        {
            if (currentstyle.isPicture())
            {
                int ht = (gzoom*currentstyle.getPicture()->height())/100;
                int wt = (gzoom*currentstyle.getPicture()->width())/100;
                  bool willscale = false;
                  if (ht > availht)
                    {
                      wt = (wt*availht)/ht;
                      ht = availht;
                      willscale = true;
                    }
                int ascent = fc->ascent(currentstyle)/2;
                int yoffset = ht/2 + ascent;

                QPixmap pc;
                if ((willscale || gzoom != 100) && currentstyle.canScale())
                {
                    QImage im = currentstyle.getPicture()->smoothScale(wt,ht);
                    pc.convertFromImage(im);
                }
                else
                {
                    pc.convertFromImage(*currentstyle.getPicture());
                }
                _p->drawPixmap( currentx, _y-yoffset, pc );
                currentx += wt;
            }
            else
            {
                if (currentstyle.isMono() && !fc->hasCourier())
                {
                    int cw = (7*fc->getsize(currentstyle))/10;
                    int w = cw*(end-textstart->start);
                    Highlight(_p, drawBackground, currentx, _y, w, bgColour);
                    if (currentstyle.isUnderline())
                    {
                        _p->drawLine( currentx, _y+voffset, currentx + w, _y+voffset);
                    }
                    if (currentstyle.isStrikethru())
                    {
                        int ascent = fc->ascent(currentstyle)/3;
                        _p->drawLine( currentx, _y-ascent+voffset, currentx + w, _y-ascent+voffset);
                    }
                    QString str = text.mid(textstart->start, end-textstart->start);

                    for (unsigned int i = 0; i < str.length(); i++)
                    {
#ifdef _WINDOWS
                        _p->drawText( currentx, _y+voffset, QString(str.at(i)));
#else
                        _p->drawText( currentx, _y+voffset, QString(str[i]));
#endif
                        currentx += cw;
                    }
                }
                else
                {
                    QFontMetrics fm(f);
                    int w;
                    if (just)
                    {
                        int lastspace = -1;
                        int nsp = 0;
                        int cx = currentx;
                        while ((nsp = str.find(" ", lastspace+1)) >= 0)
                        {
                            if (nsp+textstart->start >= nonspace)
                            {
                                spacenumber++;
                                int nexttoadd = (extraspace*spacenumber+spaces/2)/spaces - spacesofar;
                                QString nstr = str.mid(lastspace+1, nsp-lastspace);
//                          qDebug("str:%s: last:%d new:%d nstr:%s:", (const char*)str, lastspace, nsp, (const char*)nstr);
                                int lw = fm.width(nstr);
                                Highlight(_p, drawBackground, cx, _y, lw, bgColour);
                                _p->drawText( cx, _y+voffset, nstr);
                                Highlight(_p, drawBackground, cx+lw, _y, nexttoadd, bgColour);
                                cx += lw+nexttoadd;
                                spacesofar += nexttoadd;
                                lastspace = nsp;
                            }
                            else
                            {
                                QString nstr = str.mid(lastspace+1, nsp-lastspace);
//                          qDebug("str:%s: last:%d new:%d nstr:%s:", (const char*)str, lastspace, nsp, (const char*)nstr);
                                int lw = fm.width(nstr);
                                Highlight(_p, drawBackground, cx, _y, lw, bgColour);
                                _p->drawText( cx, _y+voffset, nstr);
                                cx += lw;
                                lastspace = nsp;
                            }
                        }
                        QString nstr = str.right(str.length()-1-lastspace);
                        int lw = fm.width(nstr);
                        Highlight(_p, drawBackground, cx, _y, lw, bgColour);
                        _p->drawText( cx, _y+voffset, nstr);
                        cx += lw;
                        w = cx - currentx;
                    }
                    else
                    {
                        int lw = fm.width(str);
                        Highlight(_p, drawBackground, currentx, _y, lw, bgColour);
                        _p->drawText( currentx, _y+voffset, str);
                        w = lw;
                    }
                    if (currentstyle.isUnderline())
                    {
                        _p->drawLine( currentx, _y+voffset, currentx + w, _y+voffset);
                    }
                    if (currentstyle.isStrikethru())
                    {
                        int ascent = fc->ascent(currentstyle)/3;
                        _p->drawLine( currentx, _y-ascent+voffset, currentx + w, _y-ascent+voffset);
                    }
                    currentx += w;
                }
            }
        }
        textstart = textend;
    }
    while (textend != segs.end() && textstart->start < len);
/*
 if (firstColour ==  bgColour)
     {
        Highlight(_p, drawBackground, currentx, _y, scwidth - (currentx + _lborder + _rborder), bgColour);
     }
 */
}

void CDrawBuffer::Highlight(QPainter* _p, bool drawBackground, int _x, int _y, int w, QColor bgColour)
{
  if (drawBackground)
    {
      _p->fillRect(_x, _y-m_ascent, w, m_lineSpacing, bgColour);
    }
}

CStyle CDrawBuffer::laststyle()
{
    return segs.last().style;
}

CStyle CDrawBuffer::firststyle()
{
    return segs.first().style;
}

linkType CDrawBuffer::getLinkType(int numchars, size_t& tgt, size_t& offset, size_t& pictgt, QImage*& img, size_t& tabletgt)
{
  linkType ret = eNone;
    int end = 0;
    CStyle currentstyle;
    CList<textsegment>::iterator textstart = segs.begin();
    CList<textsegment>::iterator textend = textstart;
    do
    {
        textend++;
        end = (textend != segs.end()) ? textend->start : len;
        currentstyle = textstart->style;
/*
        if (currentstyle.isPicture()) qDebug("Passed thru picture");
        if (currentstyle.getLink()) qDebug("Passed thru link");
        //qDebug("islink:%d - %d", numchars, end);
*/
        textstart = textend;
    }
    while (textend != segs.end() && end <= numchars);
    img = currentstyle.getPicture();
    if (currentstyle.getPictureLink())
    {
        pictgt = currentstyle.getPictureLinkData();
        ret |= ePicture;
    }
    if (currentstyle.getLink())
    {
        tgt = currentstyle.getData();
        offset = currentstyle.getOffset();
        ret |= eLink;
    }
    if (currentstyle.isTable())
      {
        tabletgt = currentstyle.getTable();
        ret |= eTable;
      } 
    return ret;
}

void CDrawBuffer::resize(int availht)
{
    int gzoom = fc->gzoom();
    m_ascent = m_descent = m_lineSpacing = m_lineExtraSpacing = 0;
    /*
    int t_ascent = 0;
    int t_descent = 0;
    int t_lineExtraSpacing = 0;
    */
    int t_lineSpacing = 0;
   m_hastext = false;
    for (CList<textsegment>::iterator iter = segs.begin(); iter != segs.end() && iter->start <= len; )
    {
       CStyle _style = iter->style;
       if (!_style.isPicture())
         {
            m_hastext = true;
            break;
         }
       iter++;
    }
   if (m_hastext)
     {
       int p_linespacing = 0;
        for (CList<textsegment>::iterator iter = segs.begin(); iter != segs.end() && iter->start <= len; )
          {
             CList<textsegment>::iterator next = iter;
             iter++;
             int st = next->start;
             if (st < 0) st = 0;
             
             CStyle _style = next->style;
             
             int linespacing, ascent, descent, extra;
             
             ascent = fc->ascent(_style);
             descent = fc->descent(_style);
             linespacing = fc->lineSpacing(_style);
             extra = linespacing - ascent - descent;
             /*
              if (ascent > t_ascent) t_ascent = ascent;
              if (descent > t_descent) t_descent = descent;
              if (extra > t_lineExtraSpacing) t_lineExtraSpacing = extra;
              t_lineSpacing = t_ascent+t_descent+t_lineExtraSpacing;
              */
             if (linespacing > t_lineSpacing) t_lineSpacing = linespacing;
             if (_style.isPicture())
               {
                  int ht = (gzoom*_style.getPicture()->height())/100;
                  int wt = (gzoom*_style.getPicture()->width())/100;

                  bool willscale = false;
                  if (ht > availht)
                    {
                      wt = (wt*availht)/ht;
                      ht = availht;
                      willscale = true;
                    }
                  if (willscale || _style.canScale())
                    {
                       descent = ((gzoom*_style.getPicture()->height())/100-ascent)/2;
                       ascent = ((gzoom*_style.getPicture()->height())/100+ascent)/2;
                    }
                  else
                    {
                       descent = (_style.getPicture()->height()-ascent)/2;
                       ascent = (_style.getPicture()->height()+ascent)/2;
                    }
                  int lineSpacing = ascent+descent;
                  if (lineSpacing > p_linespacing)
                    {
                      p_linespacing = lineSpacing;
                    }
                  extra = 0;
               }
             
             /*
              else if (fc != NULL)
              {
              ascent = fc->ascent(_style);
              descent = fc->descent(_style);
              linespacing = fc->lineSpacing(_style);
              extra = linespacing - ascent - descent;
              }
              */
             if (ascent > m_ascent) m_ascent = ascent;
             if (descent > m_descent) m_descent = descent;
             if (extra > m_lineExtraSpacing) m_lineExtraSpacing = extra;
             m_lineSpacing = m_ascent+m_descent+m_lineExtraSpacing;
          }
        m_showPartial = (p_linespacing > t_lineSpacing);
        int lead = fc->getlead();
        if (lead != 0)
          {
             int xt = (lead*t_lineSpacing+5)/10;
             m_lineExtraSpacing += xt;
             m_lineSpacing += xt;
          }
        if (m_bSop)
          {
             int xt = ((segs.begin()->style.getExtraSpace()+fc->getextraspace())*fc->getsize(segs.begin()->style)+5)/10;
             // qDebug("ExtraSpace:%d", xt);
             m_ascent += xt;
             m_lineSpacing += xt;
          }
     }
   else
     {
        m_showPartial = true;
        int maxheight = 0;
        for (CList<textsegment>::iterator iter = segs.begin(); iter != segs.end(); iter++)
          {
             CStyle _style = iter->style;
             if (_style.isPicture())
               {
                  int ht = 0;
                  if (_style.canScale())
                    {
                       ht = ((gzoom*_style.getPicture()->height())/100);
                    }
                  else
                    {
                       ht = _style.getPicture()->height();
                    }
                  if (ht > availht)
                    {
                      ht = availht;
                    }
                  if (ht > maxheight) maxheight = ht;
               }
          }
        m_ascent = maxheight/2;
        m_descent = maxheight-m_ascent;
        m_lineExtraSpacing = 0;
        m_lineSpacing = m_ascent+m_descent;
     }
}

CStyle* CDrawBuffer::getNextLink(int& offset)
{
  CStyle* ret = NULL;
  for (CList<textsegment>::iterator iter = segs.begin(); iter != segs.end(); ++iter)
  {
    if (offset < iter->start && iter->style.getLink())
      {
        ret = &(iter->style);
        offset = iter->start;
        qDebug("Found a link at offset %d!", offset);
        break;
      }
  }
  return ret;
}

int CDrawBuffer::invertLink(int offset)
{
  for (CList<textsegment>::iterator iter = segs.begin(); iter != segs.end(); ++iter)
  {
    if (offset <= iter->start && iter->style.getLink())
      {
        iter->style.invert();
        unsigned long currentvalue = iter->style.getData();
        qDebug("Link data %u", currentvalue);
        CList<textsegment>::iterator next = iter;
        ++next;
        while (next != segs.end() && (currentvalue == next->style.getData()) && next->style.getLink())
          {
            next->style.invert();
            offset = next->start;
            iter++;
            next++;
          }
        return offset;
      }
  }
  qDebug("Failed to invert");
  return offset;
}

---