htmlobj.cpp

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

    return false;
}

void HTMLText::print( QPainter *_painter, int _tx, int _ty )
{
    if ( isNewline() )
	return;
 
    _painter->setPen( font->textColor() );
    _painter->setFont( *font );
    
    if ( isSelected() && _painter->device()->devType() != PDT_PRINTER )
    {
	_painter->drawText( x + _tx, y + _ty, text, selStart );
	int fillStart = _painter->fontMetrics().width( text, selStart );
	int fillEnd = _painter->fontMetrics().width( text, selEnd );
	_painter->fillRect( x + fillStart + _tx, y - ascent + _ty,
		fillEnd - fillStart, ascent + descent, kapp->selectColor );
	_painter->setPen( kapp->selectTextColor );
	_painter->drawText( x + _tx + fillStart, y + _ty, text + selStart,
		selEnd - selStart );
	_painter->setPen( font->textColor() );
	_painter->drawText( x + _tx + fillEnd, y + _ty, text + selEnd );
    }
    else
    {
	_painter->drawText( x + _tx, y + _ty, text );
    }
}

//-----------------------------------------------------------------------------
HTMLTextMaster::HTMLTextMaster( const char* _text, const HTMLFont *_font,
                                QPainter *_painter)
  : HTMLText( _text, _font, _painter)
{
    int runWidth = 0;
    const char *textPtr = _text;
    QFontMetrics fm(*_font);

    prefWidth = fm.width( (const char*)text );
    width = 0;
    minWidth = 0;
    
    while (*textPtr)
    {
         if (*textPtr != ' ')
         {
             runWidth += fm.width( *textPtr);
         }
         else
         {
             if (runWidth > minWidth)
             {
                 minWidth = runWidth;
             }
             runWidth = 0;
         }
         textPtr++;
    }
    if (runWidth > minWidth)
    {
        minWidth = runWidth;
    }

    strLen = strlen(text);
}
                                                                                                                 


HTMLFitType HTMLTextMaster::fitLine( bool startOfLine, bool firstRun, int widthLeft )
{
    /* split ourselves up :) */
    if ( isNewline() )
    	return HTMLCompleteFit;

    // Remove existing slaves	
    HTMLObject *next_obj = next();
    while (next_obj && next_obj->isSlave())
    {
    	setNext(next_obj->next());
    	delete next_obj;
    	next_obj = next();
    }

    // Turn all text over to our slave.
    HTMLTextSlave *text_slave = new HTMLTextSlave( this, 0, strLen);

    text_slave->setNext(next());
    setNext(text_slave);
    return HTMLCompleteFit;
}

//-----------------------------------------------------------------------------
HTMLTextSlave::HTMLTextSlave( HTMLTextMaster *_owner, 
                              short _posStart, short _posLen) 
        : owner(_owner), 
          posStart(_posStart), 
          posLen(_posLen)
{
    QFontMetrics fm (*(_owner->font));
    ascent = _owner->getAscent();
    descent = _owner->getDescent();
    width = fm.width( (const char*) &(_owner->text[_posStart]), _posLen );
}

HTMLFitType HTMLTextSlave::fitLine( bool startOfLine, bool firstRun,
                             int widthLeft )
{
    int newLen;
    int newWidth;
    char *splitPtr;

    const char *text = owner->text;
    // Set font settings in painter for correct width calculation
    QFontMetrics fm( *(owner->font) );

    // Remove existing slaves	
    HTMLObject *next_obj = next();

    if (next_obj && next_obj->isSlave())
    {
	// 
	//printf("TextSlave: recover layout\n");
	do
	{
    	    setNext(next_obj->next());
            delete next_obj;
    	    next_obj = next();
        }
        while (next_obj && next_obj->isSlave());
        posLen = owner->strLen-posStart;
    }

    if (startOfLine && (text[posStart] == ' ') && (widthLeft >= 0) )
    {
    	// Skip leading space
    	posStart++;
    	posLen--;
    }
    text += posStart;

    width = fm.width( text, posLen ); 
    
    if ((width <= widthLeft) || (posLen <= 1) || (widthLeft < 0) )
      {
        // Text fits completely 
        if (!next() || next()->isSeparator() || next()->isNewline())
	    return HTMLCompleteFit;
	    
	// Text is followed by more text... break it before the last word.
	splitPtr = rindex( text+1 , ' '); 
	if (!splitPtr)
	    return HTMLCompleteFit;
    }
    else
    {
        splitPtr = index( text+1, ' ');
    }

    if (splitPtr)
    {
    	newLen = splitPtr - text;
    	newWidth = fm.width( text, newLen);

    	if (newWidth > widthLeft)
    	{
	  // Splitting doesn't make it fit
    	    splitPtr = 0;
    	}
    	else
    	{
	    int extraLen;
            int extraWidth;
            
            for(;;)
            {
                char *splitPtr2 = index( splitPtr+1, ' ');
                if (!splitPtr2)
                    break;
	    	extraLen = splitPtr2 - splitPtr;
                extraWidth = fm.width( splitPtr, extraLen);
                if (extraWidth+newWidth <= widthLeft)
		  {
                    // We can break on the next seperator cause it still fits
                    newLen += extraLen;
                    newWidth += extraWidth;
                    splitPtr = splitPtr2;    
                }
                else
                {	
                    // Using this seperator would over-do it.
                    break;
                }
            }
    	}	
    }
    else
    {
    	newLen = posLen;
    	newWidth = width;
    }
    
    if (!splitPtr)
    {
    	// No seperator available
    	if (firstRun == false)
    	{
    	    // Text does not fit, wait for next line
    	    return HTMLNoFit;
    	}
    
	// Text does not fit, too bad.
	// newLen & newWidth are valid
    }

    if (posLen - newLen > 0)
    {
	// Move remaining text to our text-slave
    	HTMLTextSlave *textSlave = new HTMLTextSlave( owner, 
    		posStart + newLen, posLen - newLen);

	textSlave->setNext(next());
    	setNext(textSlave);
    }

    posLen = newLen;
    width = newWidth;

    return HTMLPartialFit;
}

bool HTMLTextSlave::selectText( const QRegExp &exp )
{
    short SelStart = owner->selStart;
    short SelEnd = owner->selEnd;
    int len;
    int pos = exp.match( owner->text, posStart, &len );

    if (( pos < posStart ) || ( pos >= posStart+posLen))
    {
    	return false;
    }
    SelStart = pos;
    SelEnd = pos + len;
    if (SelEnd > posStart+posLen)
    {
	SelEnd = posStart+posLen;
    }
    owner->selStart = SelStart;
    owner->selEnd = SelEnd;
    owner->setSelected( true );
    setSelected( true );
    if ((SelStart == posStart) && (SelEnd == posStart+posLen))
    {
	setAllSelected(true);
    } 
    return true;
}
     
// get the index of the character at _xpos.
//
int HTMLTextSlave::getCharIndex( int _xpos )
{
    int charWidth, index = 0, xp = 0;
    const char *text = &(owner->text[ posStart]);

    QFontMetrics fm( *(owner->font) );

    while ( index < posLen )
    {
	charWidth = fm.width( text[ index ] );
	if ( xp + charWidth/2 >= _xpos )
	    break;
	xp += charWidth;
	index++;
    }

    return index;
}


bool HTMLTextSlave::selectText( KHTMLWidget *_htmlw, 
                                        HTMLChain *_chain, 
                                        int _x1, int _y1, 
                                        int _x2, int _y2, 
                                        int _tx, int _ty )
{
    // AAAAA
    // A I B
    // BBBBB
    typedef enum { mstA, mstAandI, mstI, 
    		   mstAandIandB, mstIandB, mstB 
    		 } metaSelectionType; 
    
    metaSelectionType metaSelection;

    short oldSelStart = owner->selStart;
    short oldSelEnd = owner->selEnd;
    short newSelStart = oldSelStart;
    short newSelEnd = oldSelEnd;

    if ( _y1 >= y + descent)
    {
	// Only lines behind us are selected
	metaSelection = mstB;
    }
    else if ( _y2 <= y - ascent )
    {
    	// Only lines before us are selected
	metaSelection = mstA;
    }
    // start and end are on this line
    else if ( _y1 >= y - ascent && _y2 <= y + descent )
    {
	if ( _x1 > _x2 )
	{
	    int tmp = _x1;
	    _x1 = _x2;
	    _x2 = tmp;
	}
	if ( _x1 >= x + width)
	{
	    // Only text behind us is selected
	    metaSelection = mstB;
	}
	else if ( _x2 <= x)
	{
	    // Only text in front of us is selected
	    metaSelection = mstA;
	}
	else
	{
	    // We are (partly) selected
	    if ( _x1 > x )
	    {
	        // There is no text in front of us selected
	    	newSelStart = posStart+getCharIndex( _x1 - x );
		if ( _x2 < x + width )
		{
		    newSelEnd = posStart + getCharIndex( _x2 - x );
		    // There is no text in front or after us selected
		    metaSelection = mstI;
		}
		else
		{
		    // There is also text behind us selected
		    metaSelection = mstIandB;
		}
	    }
	    else
	    {
	        // There is text in front of us selected
		if ( _x2 < x + width )
		{
		    newSelEnd = posStart + getCharIndex( _x2 - x );
		    // There is also text in front of us selected
		    metaSelection = mstAandI;
		}
		else
		{
		    // There is also text in front and behind us selected
		    metaSelection = mstAandIandB;
		}
	    }
	}
    }
    // starts on this line and extends past it.
    else if ( _y1 >= y - ascent && _y2 > y + descent )
    {
	if ( _x1 < x + width )
	{
	    // We are selected
	    if ( _x1 > x )
	    {
		newSelStart = posStart + getCharIndex( _x1 - x );
		// There is no text in front of us selected
		metaSelection = mstIandB;
	    }
	    else
	    {
	    	// There is text in front of us selected as well
	    	metaSelection = mstAandIandB;
	    }
	}
	else
	{
	    // There is only text behind us selected
	    metaSelection = mstB;
	}
    }
    // starts before this line and ends on it.
    else if ( _y1 < y - ascent && _y2 <= y + descent )
    {
	if ( _x2 > x )
	{
	    // We are selected
	    if ( _x2 < x + width )
	    {
		newSelEnd = posStart+getCharIndex( _x2 - x );
		// There is no text behind us selected
		metaSelection = mstAandI;
	    }
	    else
	    {
	    	// There is text behind us selected as well
	    	metaSelection = mstAandIandB;
	    }
	}
	else
	{
	    // There is only text in front of us selected;
	    metaSelection = mstA;
	}
    }
    // starts before and ends after this line
    else if ( _y1 < y - ascent && _y2 > y + descent )
    {
	metaSelection = mstAandIandB;
    }

    switch (metaSelection) 
    {
    case mstA:	
    	    if (newSelEnd > posStart)
    	        newSelEnd = posStart;
    	    if (newSelStart > posStart)
    	        newSelStart = posStart;
	break;
		
    case mstB:  
	    if (newSelEnd < posStart+posLen)
 		newSelEnd = posStart+posLen;
	    if (newSelStart < posStart+posLen)
    	        newSelStart = posStart+posLen;
	break;    	

    case mstAandI:
    	if (newSelStart > posStart)
    	    newSelStart = posStart; 	          
	break;

    case mstI:
	break;

    case mstIandB:
    	if (newSelEnd < posStart+posLen)
    	    newSelEnd = posStart+posLen; 	          
	break;

    case mstAandIandB:
    	if (newSelStart > posStart)
    	    newSelStart = posStart; 	          
    	if (newSelEnd < posStart+posLen)
    	    newSelEnd = posStart+posLen; 	          
	break;

    default:
    	// Error	
    	newSelStart = 0;
    	newSelEnd = 0;
	break;
    }

    bool selectIt;
    bool selectItAll;

    if (newSelStart == newSelEnd)
    {
    	selectIt = false;
    	selectItAll = false;
	newSelStart = 0;
	newSelEnd = 0;
    }
    else
    {
    	selectIt = (newSelStart < (posStart+posLen)) &&
    		   (newSelEnd   > posStart);
	selectItAll = (newSelStart <= posStart) &&
		      (newSelEnd >= posStart+posLen);
    }

    if ( (selectIt != isSelected()) || (selectItAll != isAllSelected()) ||
        (oldSelStart != newSelStart) || (oldSelEnd != newSelEnd) )
    {
	owner->selStart = newSelStart;
	owner->selEnd = newSelEnd;
	owner->setSelected( newSelStart != newSelEnd );
	setSelected( selectIt );
	setAllSelected( selectItAll );
	_chain->push( this );
	_htmlw->paint(_chain, x + _tx, y - ascent + _ty, width, ascent+descent);
	_chain->pop();
    }

    return selectIt;
}

bool HTMLTextSlave::print( QPainter *_painter, 
                                   int _x, int _y, 
                                   int _width, int _height, 
                                   int _tx, int _ty, bool toPrinter )
{
    if ( _y + _height < y - getAscent() || _y > y + getDescent() )
	return false;

    if ( toPrinter )
    {
	if ( _y + _height < y + descent )
	    return true;
	if ( isPrinted() )
	    return false;
	setPrinted( true );
    }

    print( _painter, _tx, _ty );

    return false;
}

void HTMLTextSlave::print( QPainter *_painter, int _tx, int _ty )
{
    const char *text;
    const HTMLFont *font;

    text = &(owner->text[posStart]);
    font = owner->font;

    _painter->setPen( font->textColor() );
    _painter->setFont( *font );
    
    if ( owner->isSelected() && _painter->device()->devType() != PDT_PRINTER )
    {