You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
393 lines
9.7 KiB
393 lines
9.7 KiB
/**
|
|
* This file is part of the HTML rendering engine for KDE.
|
|
*
|
|
* Copyright (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
|
|
*
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
#include "rendering/render_generated.h"
|
|
#include "rendering/render_style.h"
|
|
#include "rendering/enumerate.h"
|
|
#include "rendering/counter_tree.h"
|
|
#include "css/css_valueimpl.h"
|
|
|
|
using namespace tdehtml;
|
|
using namespace Enumerate;
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
RenderCounterBase::RenderCounterBase(DOM::NodeImpl* node)
|
|
: RenderText(node,0), m_counterNode(0)
|
|
{
|
|
}
|
|
|
|
void RenderCounterBase::layout()
|
|
{
|
|
TDEHTMLAssert( needsLayout() );
|
|
|
|
if ( !minMaxKnown() )
|
|
calcMinMaxWidth();
|
|
|
|
RenderText::layout();
|
|
}
|
|
|
|
void RenderCounterBase::calcMinMaxWidth()
|
|
{
|
|
TDEHTMLAssert( !minMaxKnown() );
|
|
|
|
generateContent();
|
|
|
|
if (str) str->deref();
|
|
str = new DOM::DOMStringImpl(m_item.unicode(), m_item.length());
|
|
str->ref();
|
|
|
|
RenderText::calcMinMaxWidth();
|
|
}
|
|
|
|
|
|
void RenderCounterBase::updateContent()
|
|
{
|
|
setMinMaxKnown(false);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
RenderCounter::RenderCounter(DOM::NodeImpl* node, const DOM::CounterImpl* counter)
|
|
: RenderCounterBase(node), m_counter(counter)
|
|
{
|
|
}
|
|
|
|
TQString RenderCounter::toListStyleType(int value, int total, EListStyleType type)
|
|
{
|
|
TQString item;
|
|
switch(type)
|
|
{
|
|
case LNONE:
|
|
break;
|
|
// Glyphs: (these values are not really used and instead handled by RenderGlyph)
|
|
case LDISC:
|
|
item = TQChar(0x2022);
|
|
break;
|
|
case LCIRCLE:
|
|
item = TQChar(0x25e6);
|
|
break;
|
|
case LSQUARE:
|
|
item = TQChar(0x25a0);
|
|
break;
|
|
case LBOX:
|
|
item = TQChar(0x25a1);
|
|
break;
|
|
case LDIAMOND:
|
|
item = TQChar(0x25c6);
|
|
break;
|
|
// Numeric:
|
|
case LDECIMAL:
|
|
item.setNum ( value );
|
|
break;
|
|
case DECIMAL_LEADING_ZERO: {
|
|
int decimals = 2;
|
|
int t = total/100;
|
|
while (t>0) {
|
|
t = t/10;
|
|
decimals++;
|
|
}
|
|
decimals = kMax(decimals, 2);
|
|
TQString num = TQString::number(value);
|
|
item.fill('0',decimals-num.length());
|
|
item.append(num);
|
|
break;
|
|
}
|
|
case ARABIC_INDIC:
|
|
item = toArabicIndic( value );
|
|
break;
|
|
case LAO:
|
|
item = toLao( value );
|
|
break;
|
|
case PERSIAN:
|
|
case URDU:
|
|
item = toPersianUrdu( value );
|
|
break;
|
|
case THAI:
|
|
item = toThai( value );
|
|
break;
|
|
case TIBETAN:
|
|
item = toTibetan( value );
|
|
break;
|
|
// Algoritmic:
|
|
case LOWER_ROMAN:
|
|
item = toRoman( value, false );
|
|
break;
|
|
case UPPER_ROMAN:
|
|
item = toRoman( value, true );
|
|
break;
|
|
case HEBREW:
|
|
item = toHebrew( value );
|
|
break;
|
|
case ARMENIAN:
|
|
item = toArmenian( value );
|
|
break;
|
|
case GEORGIAN:
|
|
item = toGeorgian( value );
|
|
break;
|
|
// Alphabetic:
|
|
case LOWER_ALPHA:
|
|
case LOWER_LATIN:
|
|
item = toLowerLatin( value );
|
|
break;
|
|
case UPPER_ALPHA:
|
|
case UPPER_LATIN:
|
|
item = toUpperLatin( value );
|
|
break;
|
|
case LOWER_GREEK:
|
|
item = toLowerGreek( value );
|
|
break;
|
|
case UPPER_GREEK:
|
|
item = toUpperGreek( value );
|
|
break;
|
|
case HIRAGANA:
|
|
item = toHiragana( value );
|
|
break;
|
|
case HIRAGANA_IROHA:
|
|
item = toHiraganaIroha( value );
|
|
break;
|
|
case KATAKANA:
|
|
item = toKatakana( value );
|
|
break;
|
|
case KATAKANA_IROHA:
|
|
item = toKatakanaIroha( value );
|
|
break;
|
|
// Ideographic:
|
|
case JAPANESE_FORMAL:
|
|
item = toJapaneseFormal( value );
|
|
break;
|
|
case JAPANESE_INFORMAL:
|
|
item = toJapaneseInformal( value );
|
|
break;
|
|
case SIMP_CHINESE_FORMAL:
|
|
item = toSimpChineseFormal( value );
|
|
break;
|
|
case SIMP_CHINESE_INFORMAL:
|
|
item = toSimpChineseInformal( value );
|
|
break;
|
|
case TRAD_CHINESE_FORMAL:
|
|
item = toTradChineseFormal( value );
|
|
break;
|
|
case CJK_IDEOGRAPHIC:
|
|
// CSS 3 List says treat as trad-chinese-informal
|
|
case TRAD_CHINESE_INFORMAL:
|
|
item = toTradChineseInformal( value );
|
|
break;
|
|
default:
|
|
item.setNum ( value );
|
|
break;
|
|
}
|
|
return item;
|
|
}
|
|
|
|
void RenderCounter::generateContent()
|
|
{
|
|
bool counters;
|
|
counters = !m_counter->separator().isNull();
|
|
|
|
if (!m_counterNode)
|
|
m_counterNode = getCounter(m_counter->identifier().string(), true, counters);
|
|
|
|
int value = m_counterNode->count();
|
|
if (m_counterNode->isReset()) value = m_counterNode->value();
|
|
int total = value;
|
|
if (m_counterNode->parent()) total = m_counterNode->parent()->total();
|
|
m_item = toListStyleType(value, total, (EListStyleType)m_counter->listStyle());
|
|
|
|
if (counters) {
|
|
CounterNode *counter = m_counterNode->parent();
|
|
// we deliberately do not render the root counter-node
|
|
while(counter->parent() && !(counter->isReset() && counter->parent()->isRoot())) {
|
|
value = counter->count();
|
|
total = counter->parent()->total();
|
|
m_item = toListStyleType(value, total, (EListStyleType)m_counter->listStyle()) + m_counter->separator().string() + m_item;
|
|
counter = counter->parent();
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
RenderQuote::RenderQuote(DOM::NodeImpl* node, EQuoteContent type)
|
|
: RenderCounterBase(node), m_quoteType(type)
|
|
{
|
|
}
|
|
|
|
|
|
int RenderQuote::quoteCount() const
|
|
{
|
|
switch(m_quoteType) {
|
|
case OPEN_QUOTE:
|
|
case NO_OPEN_QUOTE:
|
|
return 1;
|
|
case CLOSE_QUOTE:
|
|
case NO_CLOSE_QUOTE:
|
|
return -1;
|
|
case NO_QUOTE:
|
|
return 0;
|
|
}
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
|
|
void RenderQuote::generateContent()
|
|
{
|
|
bool visual;
|
|
if (m_quoteType == NO_CLOSE_QUOTE || m_quoteType == NO_OPEN_QUOTE)
|
|
visual = false;
|
|
else
|
|
visual = true;
|
|
|
|
if (!m_counterNode)
|
|
m_counterNode = getCounter("-khtml-quotes", visual, false);
|
|
|
|
int value = m_counterNode->count();
|
|
if (m_counterNode->isReset()) value = m_counterNode->value();
|
|
switch (m_quoteType) {
|
|
case OPEN_QUOTE:
|
|
m_item = style()->openQuote( value );
|
|
break;
|
|
case CLOSE_QUOTE:
|
|
m_item = style()->closeQuote( value );
|
|
break;
|
|
case NO_OPEN_QUOTE:
|
|
case NO_CLOSE_QUOTE:
|
|
case NO_QUOTE:
|
|
m_item = TQString();
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
RenderGlyph::RenderGlyph(DOM::NodeImpl* node, EListStyleType type)
|
|
: RenderBox(node), m_type(type)
|
|
{
|
|
setInline(true);
|
|
// setReplaced(true);
|
|
}
|
|
|
|
void RenderGlyph::setStyle(RenderStyle *_style)
|
|
{
|
|
RenderBox::setStyle(_style);
|
|
|
|
const TQFontMetrics &fm = style()->fontMetrics();
|
|
TQRect xSize= fm.boundingRect('x');
|
|
m_height = xSize.height();
|
|
m_width = xSize.width();;
|
|
|
|
switch(m_type) {
|
|
// Glyphs:
|
|
case LDISC:
|
|
case LCIRCLE:
|
|
case LSQUARE:
|
|
case LBOX:
|
|
case LDIAMOND:
|
|
case LNONE:
|
|
break;
|
|
default:
|
|
// not a glyph !
|
|
assert(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void RenderGlyph::calcMinMaxWidth()
|
|
{
|
|
m_minWidth = m_width;
|
|
m_maxWidth = m_width;
|
|
|
|
setMinMaxKnown();
|
|
}
|
|
|
|
short RenderGlyph::lineHeight(bool /*b*/) const
|
|
{
|
|
return height();
|
|
}
|
|
|
|
short RenderGlyph::baselinePosition(bool /*b*/) const
|
|
{
|
|
return height();
|
|
}
|
|
|
|
void RenderGlyph::paint(PaintInfo& paintInfo, int _tx, int _ty)
|
|
{
|
|
if (paintInfo.phase != PaintActionForeground)
|
|
return;
|
|
|
|
if (style()->visibility() != VISIBLE) return;
|
|
|
|
_tx += m_x;
|
|
_ty += m_y;
|
|
|
|
if((_ty > paintInfo.r.bottom()) || (_ty + m_height <= paintInfo.r.top()))
|
|
return;
|
|
|
|
TQPainter* p = paintInfo.p;
|
|
|
|
const TQColor color( style()->color() );
|
|
p->setPen( color );
|
|
|
|
int xHeight = m_height;
|
|
int bulletWidth = (xHeight+1)/2;
|
|
int yoff = (xHeight - 1)/4;
|
|
TQRect marker(_tx, _ty + yoff, bulletWidth, bulletWidth);
|
|
|
|
switch(m_type) {
|
|
case LDISC:
|
|
p->setBrush( color );
|
|
p->drawEllipse( marker );
|
|
return;
|
|
case LCIRCLE:
|
|
p->setBrush( TQt::NoBrush );
|
|
p->drawEllipse( marker );
|
|
return;
|
|
case LSQUARE:
|
|
p->setBrush( color );
|
|
p->drawRect( marker );
|
|
return;
|
|
case LBOX:
|
|
p->setBrush( TQt::NoBrush );
|
|
p->drawRect( marker );
|
|
return;
|
|
case LDIAMOND: {
|
|
static TQPointArray diamond(4);
|
|
int x = marker.x();
|
|
int y = marker.y();
|
|
int s = bulletWidth/2;
|
|
diamond[0] = TQPoint(x+s, y);
|
|
diamond[1] = TQPoint(x+2*s, y+s);
|
|
diamond[2] = TQPoint(x+s, y+2*s);
|
|
diamond[3] = TQPoint(x, y+s);
|
|
p->setBrush( color );
|
|
p->drawConvexPolygon( diamond, 0, 4 );
|
|
return;
|
|
}
|
|
case LNONE:
|
|
return;
|
|
default:
|
|
// not a glyph
|
|
assert(false);
|
|
}
|
|
}
|
|
|