~g-bluehut/ubuntu-terminal-app/whitespacefix

    fileMap(0)

{

  if (tmpFile.open())

    tmpFile.setAutoRemove(true);

    ion = tmpFile.handle();

  }

    //if mmap'ing fails, fall back to the read-lseek combination

    if ( fileMap == MAP_FAILED )

    {

            fileMap = 0;

            qDebug() << __FILE__ << __LINE__ << ": mmap'ing history failed.  errno = " << errno;

    }

{

  if ( fileMap )

          unmap();

  readWriteBalance++;

 

  int rc = 0;

 

void HistoryFile::get(unsigned char* bytes, int len, int loc)

{

  //calls (decided by using MAP_THRESHOLD) then mmap the log

  //file to improve performance.

  readWriteBalance--;

            bytes[i]=fileMap[loc+i];

  }

  else

      int rc = 0;

 

      if (loc < 0 || len < 0 || loc + len > length)

 

// History Scroll File //////////////////////////////////////

 

   The history scroll makes a Row(Row(Cell)) from

   two history buffers. The index buffer contains

   start of line positions which refere to the cells

HistoryScrollFile::~HistoryScrollFile()

{

}

int HistoryScrollFile::getLines()

{

  return index.len() / sizeof(int);

{

  if (lineno <= 0) return 0;

  if (lineno <= getLines())

    if (!index.isMapped())

            index.map();

    int res;

    index.get((unsigned char*)&res,sizeof(int),(lineno-1)*sizeof(int));

    return res;

bool HistoryScrollBuffer::isWrappedLine(int lineNumber)

{

  Q_ASSERT( lineNumber >= 0 && lineNumber < _maxLineCount );

  if (lineNumber < _usedLines)

  {

    //kDebug() << "Line" << lineNumber << "wrapped is" << _wrappedLine[bufferIndex(lineNumber)];

 

  Q_ASSERT( lineNumber < _maxLineCount );

 

  {

    memset(buffer, 0, count * sizeof(Character));

    return;

  }

  const HistoryLine& line = _historyBuffer[bufferIndex(lineNumber)];

 

  //kDebug() << "startCol " << startColumn;

  //kDebug() << "count " << count;

 

  Q_ASSERT( startColumn <= line.size() - count );

  memcpy(buffer, line.constData() + startColumn , count * sizeof(Character));

}

 

{

    HistoryLine* oldBuffer = _historyBuffer;

    HistoryLine* newBuffer = new HistoryLine[lineCount];

    for ( int i = 0 ; i < qMin(_usedLines,(int)lineCount) ; i++ )

    {

        newBuffer[i] = oldBuffer[bufferIndex(i)];

    }

    _usedLines = qMin(_usedLines,(int)lineCount);

    _maxLineCount = lineCount;

    _head = ( _usedLines == _maxLineCount ) ? 0 : _usedLines-1;

        return (_head+lineNumber+1) % _maxLineCount;

    }

    else

        return lineNumber;

    }

}

void HistoryScrollBlockArray::addCells(const Character a[], int count)

{

  Block *b = m_blockArray.lastBlock();

  if (!b) return;

 

  // put cells in block's data

void CompactHistoryBlockList::deallocate(void* ptr)

{

  Q_ASSERT( !list.isEmpty());

  CompactHistoryBlock *block = list.at(i);

  while ( i<list.size() && !block->contains(ptr) )

    i++;

    block=list.at(i);

  }

 

  Q_ASSERT( i<list.size() );

  block->deallocate();

 

  if (!block->isInUse())

  return blockList.allocate(size);

}

 

  : blockList(bList),

    formatLength(0)

{

  length=line.size();

  if (line.size() > 0) {

    formatLength=1;

    int k=1;

    // count number of different formats in this text line

    Character c = line[0];

    while ( k<length )

      }

      k++;

    }

    //kDebug() << "number of different formats in string: " << formatLength;

    formatArray = (CharacterFormat*) blockList.allocate(sizeof(CharacterFormat)*formatLength);

    Q_ASSERT (formatArray!=NULL);

    text = (quint16*) blockList.allocate(sizeof(quint16)*line.size());

    Q_ASSERT (text!=NULL);

    length=line.size();

    formatLength=formatLength;

    wrapped=false;

    // record formats and their positions in the format array

    c=line[0];

    formatArray[0].setFormat ( c );

    formatArray[0].startPos=0;                        // there's always at least 1 format (for the entire line, unless a change happens)

    k=1;                                              // look for possible format changes

    int j=1;

    while ( k<length && j<formatLength )

      }

      k++;

    }

    // copy character values

    for ( int i=0; i<line.size(); i++ )

    {

    blockList.deallocate(text);

    blockList.deallocate(formatArray);

  }

}

 

void CompactHistoryLine::getCharacter ( int index, Character &r )

 

HistoryScroll* HistoryTypeFile::scroll(HistoryScroll *old) const

{

     return old; // Unchanged.

 

  HistoryScroll *newScroll = new HistoryScrollFile(m_fileName);

  }

 

  delete old;

}

 

int HistoryTypeFile::maximumLineCount() const