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.
koffice/lib/kformula/fontstyle.cc

892 lines
29 KiB

/* This file is part of the KDE project
Copyright (C) 2003 Ulrich Kuettler <ulrich.kuettler@gmx.de>
Copyright (C) 2006 Alfredo Beaumont Sainz <alfredo.beaumont@gmail.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 <tqpainter.h>
#include <tqpen.h>
#include <tqfontdatabase.h>
#include <tqapplication.h>
#include <kstaticdeleter.h>
#include <klocale.h>
#include <kstandarddirs.h>
#include <kio/netaccess.h>
#include <kio/job.h>
#include <kmessagebox.h>
#include "fontstyle.h"
KFORMULA_NAMESPACE_BEGIN
#include "unicodetable.cc"
bool FontStyle::m_installed = false;
bool FontStyle::init( ContextStyle* style, bool install )
{
if (!m_installed && install)
installFonts();
m_symbolTable.init( style->getMathFont() );
return true;
}
// Cache the family list from TQFontDatabase after fixing it up (no foundry, lowercase)
class FontList {
public:
FontList() {
TQFontDatabase db;
const TQStringList lst = db.tqfamilies();
for ( TQStringList::const_iterator it = lst.begin(), end = lst.end() ; it != end ; ++it ) {
const TQString name = *it;
int i = name.find('[');
TQString family = name;
// Remove foundry
if ( i > -1 ) {
const int li = name.findRev(']');
if (i < li) {
if (name[i - 1] == ' ')
i--;
family = name.left(i);
}
}
m_fontNames.append( family.lower() );
}
}
bool hasFont( const TQString& fontName ) const {
return m_fontNames.find( fontName ) != m_fontNames.end();
}
TQStringList m_fontNames;
};
static FontList* s_fontList = 0;
static KStaticDeleter<FontList> s_fontList_sd;
void FontStyle::testFont( TQStringList& missing, const TQString& fontName ) {
if ( !s_fontList )
s_fontList_sd.setObject( s_fontList, new FontList() );
if ( !s_fontList->hasFont( fontName ) ) {
kdWarning(39001) << "Font '" << fontName << "' not found" << endl;
missing.append( fontName );
}
}
TQStringList FontStyle::missingFonts( bool install )
{
if (!m_installed && install)
installFonts();
TQStringList missing = missingFontsInternal();
return missing;
}
TQStringList FontStyle::missingFontsInternal()
{
TQStringList missing;
testFont( missing, "cmex10" );
testFont( missing, "arev sans");
return missing;
}
void FontStyle::installFonts()
{
if (m_installed)
return;
TQStringList missing = missingFontsInternal();
if (!missing.isEmpty())
{
TQStringList urlList;
for (TQStringList::iterator it = missing.begin(); it != missing.end(); ++it)
{
if ( *it == "arev sans" ) {
if (!KIO::NetAccess::exists("fonts:/Personal/Arev.ttf", true, NULL))
urlList.append(locate("data", "kformula/fonts/Arev.ttf"));
if (!KIO::NetAccess::exists("fonts:/Personal/ArevIt.ttf", true, NULL))
urlList.append(locate("data", "kformula/fonts/ArevIt.ttf"));
if (!KIO::NetAccess::exists("fonts:/Personal/ArevBd.ttf", true, NULL))
urlList.append(locate("data", "kformula/fonts/ArevBd.ttf"));
if (!KIO::NetAccess::exists("fonts:/Personal/ArevBI.ttf", true, NULL))
urlList.append(locate("data", "kformula/fonts/ArevBI.ttf"));
}
else {
if (!KIO::NetAccess::exists("fonts:/Personal/" + *it + ".ttf", true, NULL))
urlList.append(locate("data", "kformula/fonts/" + *it + ".ttf"));
}
}
KIO::copy(urlList, "fonts:/Personal/", false);
KMessageBox::information(tqApp->mainWidget(),
i18n("Some fonts have been installed to assure that symbols in formulas are properly visualized. You must restart the application in order so that changes take effect"));
}
m_installed = true;
}
Artwork* FontStyle::createArtwork( SymbolType type ) const
{
return new Artwork( type );
}
// We claim that all chars come from the same font.
// It's up to the font tables to ensure this.
const TQChar leftRoundBracket[] = {
0x30, // uppercorner
0x40, // lowercorner
0x42 // line
};
const TQChar leftSquareBracket[] = {
0x32, // uppercorner
0x34, // lowercorner
0x36 // line
};
const TQChar leftCurlyBracket[] = {
0x38, // uppercorner
0x3A, // lowercorner
0x3E, // line
0x3C // middle
};
const TQChar leftLineBracket[] = {
0x36, // line
0x36, // line
0x36 // line
};
const TQChar rightLineBracket[] = {
0x37, // line
0x37, // line
0x37 // line
};
const TQChar rightRoundBracket[] = {
0x31, // uppercorner
0x41, // lowercorner
0x43 // line
};
const TQChar rightSquareBracket[] = {
0x33, // uppercorner
0x35, // lowercorner
0x37 // line
};
const TQChar rightCurlyBracket[] = {
0x39, // uppercorner
0x3B, // lowercorner
0x3E, // line
0x3D // middle
};
static const char cmex_LeftSquareBracket = 163;
static const char cmex_RightSquareBracket = 164;
static const char cmex_LeftCurlyBracket = 169;
static const char cmex_RightCurlyBracket = 170;
static const char cmex_LeftCornerBracket = 173;
static const char cmex_RightCornerBracket = 174;
static const char cmex_LeftRoundBracket = 161;
static const char cmex_RightRoundBracket = 162;
static const char cmex_SlashBracket = 177;
static const char cmex_BackSlashBracket = 178;
//static const char cmex_LeftLineBracket = 0x4b;
//static const char cmex_RightLineBracket = 0x4b;
// use the big symbols here
static const char cmex_Int = 90;
static const char cmex_Sum = 88;
static const char cmex_Prod = 89;
// cmex is a special font with symbols in four sizes.
static short cmex_nextchar( short ch )
{
switch ( ch ) {
case 161: return 179;
case 162: return 180;
case 163: return 104;
case 164: return 105;
case 169: return 110;
case 170: return 111;
case 165: return 106;
case 166: return 107;
case 167: return 108;
case 168: return 109;
case 173: return 68;
case 174: return 69;
case 177: return 46;
case 178: return 47;
case 179: return 181;
case 180: return 182;
case 104: return 183;
case 105: return 184;
case 110: return 189;
case 111: return 190;
case 106: return 185;
case 107: return 186;
case 108: return 187;
case 109: return 188;
case 68: return 191;
case 69: return 192;
case 46: return 193;
case 47: return 194;
case 181: return 195;
case 182: return 33;
case 183: return 34;
case 184: return 35;
case 189: return 40;
case 190: return 41;
case 185: return 36;
case 186: return 37;
case 187: return 38;
case 188: return 39;
case 191: return 42;
case 192: return 43;
case 193: return 44;
case 194: return 45;
}
return 0;
}
bool Artwork::calcCMDelimiterSize( const ContextStyle& context,
uchar c,
luPt fontSize,
luPt parentSize )
{
TQFont f( "cmex10" );
f.setPointSizeFloat( context.layoutUnitPtToPt( fontSize ) );
TQFontMetrics fm( f );
for ( char i=1; c != 0; ++i ) {
LuPixelRect bound = fm.boundingRect( c );
luPt height = context.ptToLayoutUnitPt( bound.height() );
if ( height >= parentSize ) {
luPt width = context.ptToLayoutUnitPt( fm.width( c ) );
luPt baseline = context.ptToLayoutUnitPt( -bound.top() );
cmChar = c;
setHeight( height );
setWidth( width );
setBaseline( baseline );
return true;
}
c = cmex_nextchar( c );
}
// Build it up from pieces.
return false;
}
void Artwork::calcLargest( const ContextStyle& context,
uchar c, luPt fontSize )
{
TQFont f( "cmex10" );
f.setPointSizeFloat( context.layoutUnitPtToPt( fontSize ) );
TQFontMetrics fm( f );
cmChar = c;
for ( ;; ) {
c = cmex_nextchar( c );
if ( c == 0 ) {
break;
}
cmChar = c;
}
LuPixelRect bound = fm.boundingRect( cmChar );
luPt height = context.ptToLayoutUnitPt( bound.height() );
luPt width = context.ptToLayoutUnitPt( fm.width( cmChar ) );
luPt baseline = context.ptToLayoutUnitPt( -bound.top() );
setHeight( height );
setWidth( width );
setBaseline( baseline );
}
void Artwork::drawCMDelimiter( TQPainter& painter, const ContextStyle& style,
luPixel x, luPixel y,
luPt height )
{
TQFont f( "cmex10" );
f.setPointSizeFloat( style.layoutUnitToFontSize( height, false ) );
painter.setFont( f );
painter.drawText( style.layoutUnitToPixelX( x ),
style.layoutUnitToPixelY( y + getBaseline() ),
TQString( TQChar( cmChar ) ) );
// Debug
#if 0
TQFontMetrics fm( f );
LuPixelRect bound = fm.boundingRect( cmChar );
painter.setBrush(TQt::NoBrush);
painter.setPen(TQt::green);
painter.drawRect( style.layoutUnitToPixelX( x ),
style.layoutUnitToPixelY( y ),
fm.width( cmChar ),
bound.height() );
#endif
}
Artwork::Artwork(SymbolType t)
: baseline( -1 ), type(t)
{
}
void Artwork::calcSizes( const ContextStyle& style,
ContextStyle::TextStyle tstyle,
double factor,
luPt parentSize )
{
setBaseline( -1 );
cmChar = -1;
luPt mySize = style.getAdjustedSize( tstyle, factor );
switch (getType()) {
case LeftSquareBracket:
if ( calcCMDelimiterSize( style, cmex_LeftSquareBracket,
mySize, parentSize ) ) {
return;
}
calcRoundBracket( style, leftSquareBracket, parentSize, mySize );
break;
case RightSquareBracket:
if ( calcCMDelimiterSize( style, cmex_RightSquareBracket,
mySize, parentSize ) ) {
return;
}
calcRoundBracket( style, rightSquareBracket, parentSize, mySize );
break;
case LeftLineBracket:
calcRoundBracket( style, leftLineBracket, parentSize, mySize );
setWidth( getWidth()/2 );
break;
case RightLineBracket:
calcRoundBracket( style, rightLineBracket, parentSize, mySize );
setWidth( getWidth()/2 );
break;
case SlashBracket:
if ( calcCMDelimiterSize( style, cmex_SlashBracket,
mySize, parentSize ) ) {
return;
}
calcLargest( style, cmex_SlashBracket, mySize );
break;
case BackSlashBracket:
if ( calcCMDelimiterSize( style, cmex_BackSlashBracket,
mySize, parentSize ) ) {
return;
}
calcLargest( style, cmex_BackSlashBracket, mySize );
break;
case LeftCornerBracket:
if ( calcCMDelimiterSize( style, cmex_LeftCornerBracket,
mySize, parentSize ) ) {
return;
}
calcLargest( style, cmex_LeftCornerBracket, mySize );
break;
case RightCornerBracket:
if ( calcCMDelimiterSize( style, cmex_RightCornerBracket,
mySize, parentSize ) ) {
return;
}
calcLargest( style, cmex_RightCornerBracket, mySize );
break;
case LeftRoundBracket:
if ( calcCMDelimiterSize( style, cmex_LeftRoundBracket,
mySize, parentSize ) ) {
return;
}
calcRoundBracket( style, leftRoundBracket, parentSize, mySize );
break;
case RightRoundBracket:
if ( calcCMDelimiterSize( style, cmex_RightRoundBracket,
mySize, parentSize ) ) {
return;
}
calcRoundBracket( style, rightRoundBracket, parentSize, mySize );
break;
case EmptyBracket:
setHeight(parentSize);
//setWidth(style.getEmptyRectWidth());
setWidth(0);
break;
case LeftCurlyBracket:
if ( calcCMDelimiterSize( style, cmex_LeftCurlyBracket,
mySize, parentSize ) ) {
return;
}
calcCurlyBracket( style, leftCurlyBracket, parentSize, mySize );
break;
case RightCurlyBracket:
if ( calcCMDelimiterSize( style, cmex_RightCurlyBracket,
mySize, parentSize ) ) {
return;
}
calcCurlyBracket( style, rightCurlyBracket, parentSize, mySize );
break;
case Integral:
calcCharSize( style, style.getBracketFont(), mySize, cmex_Int );
break;
case Sum:
calcCharSize( style, style.getBracketFont(), mySize, cmex_Sum );
break;
case Product:
calcCharSize( style, style.getBracketFont(), mySize, cmex_Prod );
break;
}
}
void Artwork::calcSizes( const ContextStyle& style,
ContextStyle::TextStyle tstyle,
double factor )
{
luPt mySize = style.getAdjustedSize( tstyle, factor );
switch (type) {
case LeftSquareBracket:
calcCharSize(style, mySize, leftSquareBracketChar);
break;
case RightSquareBracket:
calcCharSize(style, mySize, rightSquareBracketChar);
break;
case LeftLineBracket:
case RightLineBracket:
calcCharSize(style, mySize, verticalLineChar);
break;
case SlashBracket:
calcCharSize(style, mySize, slashChar);
break;
case BackSlashBracket:
calcCharSize(style, mySize, backSlashChar);
break;
case LeftCornerBracket:
calcCharSize(style, mySize, leftAngleBracketChar);
break;
case RightCornerBracket:
calcCharSize(style, mySize, rightAngleBracketChar);
break;
case LeftRoundBracket:
calcCharSize(style, mySize, leftParenthesisChar);
break;
case RightRoundBracket:
calcCharSize(style, mySize, rightParenthesisChar);
break;
case EmptyBracket:
//calcCharSize(style, mySize, spaceChar);
setHeight(0);
//setWidth(style.getEmptyRectWidth());
setWidth(0);
break;
case LeftCurlyBracket:
calcCharSize(style, mySize, leftCurlyBracketChar);
break;
case RightCurlyBracket:
calcCharSize(style, mySize, rightCurlyBracketChar);
break;
case Integral:
case Sum:
case Product:
break;
}
}
void Artwork::draw(TQPainter& painter, const LuPixelRect& /*r*/,
const ContextStyle& context, ContextStyle::TextStyle tstyle,
StyleAttributes& style, const LuPixelPoint& parentOrigin)
{
luPt mySize = context.getAdjustedSize( tstyle, style.sizeFactor() );
luPixel myX = parentOrigin.x() + getX();
luPixel myY = parentOrigin.y() + getY();
/*
if ( !LuPixelRect( myX, myY, getWidth(), getHeight() ).intersects( r ) )
return;
*/
painter.setPen(context.getDefaultColor());
switch (type) {
case LeftSquareBracket:
drawCharacter(painter, context, myX, myY, mySize, leftSquareBracketChar);
break;
case RightSquareBracket:
drawCharacter(painter, context, myX, myY, mySize, rightSquareBracketChar);
break;
case LeftCurlyBracket:
drawCharacter(painter, context, myX, myY, mySize, leftCurlyBracketChar);
break;
case RightCurlyBracket:
drawCharacter(painter, context, myX, myY, mySize, rightCurlyBracketChar);
break;
case LeftLineBracket:
case RightLineBracket:
drawCharacter(painter, context, myX, myY, mySize, verticalLineChar);
break;
case SlashBracket:
drawCharacter(painter, context, myX, myY, mySize, slashChar);
break;
case BackSlashBracket:
drawCharacter(painter, context, myX, myY, mySize, backSlashChar);
break;
case LeftCornerBracket:
drawCharacter(painter, context, myX, myY, mySize, leftAngleBracketChar);
break;
case RightCornerBracket:
drawCharacter(painter, context, myX, myY, mySize, rightAngleBracketChar);
break;
case LeftRoundBracket:
drawCharacter(painter, context, myX, myY, mySize, leftParenthesisChar);
break;
case RightRoundBracket:
drawCharacter(painter, context, myX, myY, mySize, rightParenthesisChar);
break;
case EmptyBracket:
break;
case Integral:
case Sum:
case Product:
break;
}
}
void Artwork::draw(TQPainter& painter, const LuPixelRect& ,
const ContextStyle& context, ContextStyle::TextStyle tstyle,
StyleAttributes& style, luPt , const LuPixelPoint& origin)
{
luPt mySize = context.getAdjustedSize( tstyle, style.sizeFactor() );
luPixel myX = origin.x() + getX();
luPixel myY = origin.y() + getY();
/*
if ( !LuPixelRect( myX, myY, getWidth(), getHeight() ).intersects( r ) )
return;
*/
painter.setPen(context.getDefaultColor());
switch (getType()) {
case LeftSquareBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
else {
drawBigRoundBracket( painter, context, leftSquareBracket, myX, myY, mySize );
}
break;
case RightSquareBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
else {
drawBigRoundBracket( painter, context, rightSquareBracket, myX, myY, mySize );
}
break;
case LeftCurlyBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
else {
drawBigCurlyBracket( painter, context, leftCurlyBracket, myX, myY, mySize );
}
break;
case RightCurlyBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
else {
drawBigCurlyBracket( painter, context, rightCurlyBracket, myX, myY, mySize );
}
break;
case LeftLineBracket: {
luPixel halfWidth = getWidth()/2;
drawBigRoundBracket( painter, context, leftLineBracket,
myX-halfWidth, myY, mySize );
}
break;
case RightLineBracket: {
luPixel halfWidth = getWidth()/2;
drawBigRoundBracket( painter, context, rightLineBracket,
myX-halfWidth, myY, mySize );
}
break;
case SlashBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
break;
case BackSlashBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
break;
case LeftCornerBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
else drawCharacter(painter, context, myX, myY, mySize, leftAngleBracketChar);
break;
case RightCornerBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
else drawCharacter(painter, context, myX, myY, mySize, rightAngleBracketChar);
break;
case LeftRoundBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
else {
drawBigRoundBracket( painter, context, leftRoundBracket, myX, myY, mySize );
}
break;
case RightRoundBracket:
if ( cmChar != -1 ) {
drawCMDelimiter( painter, context, myX, myY, mySize );
}
else {
drawBigRoundBracket( painter, context, rightRoundBracket, myX, myY, mySize );
}
break;
case EmptyBracket:
break;
case Integral:
drawCharacter(painter, context, TQFont( "cmex10" ), myX, myY, mySize, cmex_Int);
break;
case Sum:
drawCharacter(painter, context, TQFont( "cmex10" ), myX, myY, mySize, cmex_Sum);
break;
case Product:
drawCharacter(painter, context, TQFont( "cmex10" ), myX, myY, mySize, cmex_Prod);
break;
}
// debug
// painter.setBrush(TQt::NoBrush);
// painter.setPen(TQt::green);
// painter.drawRect( context.layoutUnitToPixelX( myX ),
// context.layoutUnitToPixelY( myY ),
// context.layoutUnitToPixelX( getWidth() ),
// context.layoutUnitToPixelY( getHeight() ) );
}
void Artwork::calcCharSize( const ContextStyle& style, luPt height, TQChar ch )
{
calcCharSize( style, style.getMathFont(), height, ch );
}
void Artwork::drawCharacter( TQPainter& painter, const ContextStyle& style,
luPixel x, luPixel y,
luPt height, TQChar ch )
{
drawCharacter( painter, style, style.getMathFont(), x, y, height, ch );
}
void Artwork::calcCharSize( const ContextStyle& style, TQFont f,
luPt height, TQChar c )
{
f.setPointSizeFloat( style.layoutUnitPtToPt( height ) );
//f.setPointSize( height );
TQFontMetrics fm(f);
setWidth( style.ptToLayoutUnitPt( fm.width( c ) ) );
LuPixelRect bound = fm.boundingRect( c );
setHeight( style.ptToLayoutUnitPt( bound.height() ) );
setBaseline( style.ptToLayoutUnitPt( -bound.top() ) );
}
void Artwork::drawCharacter( TQPainter& painter, const ContextStyle& style,
TQFont f,
luPixel x, luPixel y, luPt height, uchar c )
{
f.setPointSizeFloat( style.layoutUnitToFontSize( height, false ) );
painter.setFont( f );
painter.drawText( style.layoutUnitToPixelX( x ),
style.layoutUnitToPixelY( y+getBaseline() ),
TQString( TQChar( c ) ) );
}
void Artwork::calcRoundBracket( const ContextStyle& style, const TQChar chars[],
luPt height, luPt charHeight )
{
uchar uppercorner = chars[0];
uchar lowercorner = chars[1];
//uchar line = style.symbolTable().character( chars[2] );
TQFont f = style.getBracketFont();
f.setPointSizeFloat( style.layoutUnitPtToPt( charHeight ) );
TQFontMetrics fm( f );
LuPtRect upperBound = fm.boundingRect( uppercorner );
LuPtRect lowerBound = fm.boundingRect( lowercorner );
//LuPtRect lineBound = fm.boundingRect( line );
setWidth( style.ptToLayoutUnitPt( fm.width( TQChar( uppercorner ) ) ) );
luPt edgeHeight = style.ptToLayoutUnitPt( upperBound.height()+lowerBound.height() );
//luPt lineHeight = style.ptToLayoutUnitPt( lineBound.height() );
//setHeight( edgeHeight + ( ( height-edgeHeight-1 ) / lineHeight + 1 ) * lineHeight );
setHeight( TQMAX( edgeHeight, height ) );
}
void Artwork::drawBigRoundBracket( TQPainter& p, const ContextStyle& style, const TQChar chars[],
luPixel x, luPixel y, luPt charHeight )
{
uchar uppercorner = chars[0];
uchar lowercorner = chars[1];
uchar line = chars[2];
TQFont f = style.getBracketFont();
f.setPointSizeFloat( style.layoutUnitToFontSize( charHeight, false ) );
p.setFont(f);
TQFontMetrics fm(f);
TQRect upperBound = fm.boundingRect(uppercorner);
TQRect lowerBound = fm.boundingRect(lowercorner);
TQRect lineBound = fm.boundingRect(line);
pixel ptX = style.layoutUnitToPixelX( x );
pixel ptY = style.layoutUnitToPixelY( y );
pixel height = style.layoutUnitToPixelY( getHeight() );
// p.setPen( TQt::red );
// //p.drawRect( ptX, ptY, upperBound.width(), upperBound.height() + lowerBound.height() );
// p.drawRect( ptX, ptY, style.layoutUnitToPixelX( getWidth() ),
// style.layoutUnitToPixelY( getHeight() ) );
// p.setPen( TQt::black );
p.drawText( ptX, ptY-upperBound.top(), TQString( TQChar( uppercorner ) ) );
p.drawText( ptX, ptY+height-lowerBound.top()-lowerBound.height(),
TQString( TQChar( lowercorner ) ) );
// for printing
//pt safety = lineBound.height() / 10.0;
pixel safety = 0;
pixel gap = height - upperBound.height() - lowerBound.height();
pixel lineHeight = lineBound.height() - safety;
int lineCount = tqRound( static_cast<double>( gap ) / lineHeight );
pixel start = upperBound.height()-lineBound.top() - safety;
for (int i = 0; i < lineCount; i++) {
p.drawText( ptX, ptY+start+i*lineHeight, TQString(TQChar(line)));
}
pixel remaining = gap - lineCount*lineHeight;
pixel dist = ( lineHeight - remaining ) / 2;
p.drawText( ptX, ptY+height-upperBound.height()+dist-lineBound.height()-lineBound.top(),
TQString( TQChar( line ) ) );
}
void Artwork::calcCurlyBracket( const ContextStyle& style, const TQChar chars[],
luPt height, luPt charHeight )
{
uchar uppercorner = chars[0];
uchar lowercorner = chars[1];
//uchar line = style.symbolTable().character( chars[2] );
uchar middle = chars[3];
TQFont f = style.getBracketFont();
f.setPointSizeFloat( style.layoutUnitPtToPt( charHeight ) );
TQFontMetrics fm( f );
LuPtRect upperBound = fm.boundingRect( uppercorner );
LuPtRect lowerBound = fm.boundingRect( lowercorner );
//LuPtRect lineBound = fm.boundingRect( line );
LuPtRect middleBound = fm.boundingRect( middle );
setWidth( style.ptToLayoutUnitPt( fm.width( TQChar( uppercorner ) ) ) );
luPt edgeHeight = style.ptToLayoutUnitPt( upperBound.height()+
lowerBound.height()+
middleBound.height() );
//luPt lineHeight = style.ptToLayoutUnitPt( lineBound.height() );
//setHeight( edgeHeight + ( ( height-edgeHeight-1 ) / lineHeight + 1 ) * lineHeight );
setHeight( TQMAX( edgeHeight, height ) );
}
void Artwork::drawBigCurlyBracket( TQPainter& p, const ContextStyle& style, const TQChar chars[],
luPixel x, luPixel y, luPt charHeight )
{
//TQFont f = style.getSymbolFont();
TQFont f = style.getBracketFont();
f.setPointSizeFloat( style.layoutUnitToFontSize( charHeight, false ) );
p.setFont(f);
uchar uppercorner = chars[0];
uchar lowercorner = chars[1];
uchar line = chars[2];
uchar middle = chars[3];
TQFontMetrics fm(p.fontMetrics());
TQRect upperBound = fm.boundingRect(uppercorner);
TQRect lowerBound = fm.boundingRect(lowercorner);
TQRect middleBound = fm.boundingRect(middle);
TQRect lineBound = fm.boundingRect(line);
pixel ptX = style.layoutUnitToPixelX( x );
pixel ptY = style.layoutUnitToPixelY( y );
pixel height = style.layoutUnitToPixelY( getHeight() );
//p.setPen(TQt::gray);
//p.drawRect(x, y, upperBound.width() + offset, height);
p.drawText( ptX, ptY-upperBound.top(), TQString( TQChar( uppercorner ) ) );
p.drawText( ptX, ptY+(height-middleBound.height())/2-middleBound.top(),
TQString( TQChar( middle ) ) );
p.drawText( ptX, ptY+height-lowerBound.top()-lowerBound.height(),
TQString( TQChar( lowercorner ) ) );
// for printing
// If the world was perfect and the urw-symbol font correct
// this could be 0.
//lu safety = lineBound.height() / 10;
pixel safety = 0;
pixel lineHeight = lineBound.height() - safety;
pixel gap = height/2 - upperBound.height() - middleBound.height() / 2;
if (gap > 0) {
TQString ch = TQString(TQChar(line));
int lineCount = tqRound( gap / lineHeight ) + 1;
pixel start = (height - middleBound.height()) / 2 + safety;
for (int i = 0; i < lineCount; i++) {
p.drawText( ptX, ptY-lineBound.top()+TQMAX( start-(i+1)*lineHeight,
upperBound.width() ),
ch );
}
start = (height + middleBound.height()) / 2 - safety;
for (int i = 0; i < lineCount; i++) {
p.drawText( ptX, ptY-lineBound.top()+TQMIN( start+i*lineHeight,
height-upperBound.width()-lineBound.height() ),
ch );
}
}
}
KFORMULA_NAMESPACE_END