Renaming of files in preparation for code style tools.

Signed-off-by: Michele Calgaro <[email protected]>

1 files changed, 891 insertions, 0 deletions

diff --git a/lib/kformula/fontstyle.cpp b/lib/kformula/fontstyle.cpp
new file mode 100644
index 00000000..33f9e9f7
--- /dev/null
+++ b/lib/kformula/fontstyle.cpp
@@ -0,0 +1,891 @@
+/* This file is part of the KDE project
+   Copyright (C) 2003 Ulrich Kuettler <[email protected]>
+   Copyright (C) 2006 Alfredo Beaumont Sainz <[email protected]>
+
+   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 <tdelocale.h>
+#include <kstandarddirs.h>
+#include <tdeio/netaccess.h>
+#include <tdeio/job.h>
+#include <tdemessagebox.h>
+
+#include "fontstyle.h"
+
+
+KFORMULA_NAMESPACE_BEGIN
+
+#include "unicodetable.cpp"
+
+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.families();
+        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 (!TDEIO::NetAccess::exists("fonts:/Personal/Arev.ttf", true, NULL))
+                    urlList.append(locate("data", "kformula/fonts/Arev.ttf"));
+                if (!TDEIO::NetAccess::exists("fonts:/Personal/ArevIt.ttf", true, NULL))
+                    urlList.append(locate("data", "kformula/fonts/ArevIt.ttf"));
+                if (!TDEIO::NetAccess::exists("fonts:/Personal/ArevBd.ttf", true, NULL))
+                    urlList.append(locate("data", "kformula/fonts/ArevBd.ttf"));
+                if (!TDEIO::NetAccess::exists("fonts:/Personal/ArevBI.ttf", true, NULL))
+                    urlList.append(locate("data", "kformula/fonts/ArevBI.ttf"));
+            }
+            else {
+                if (!TDEIO::NetAccess::exists("fonts:/Personal/" + *it + ".ttf", true, NULL))
+                    urlList.append(locate("data", "kformula/fonts/" + *it + ".ttf"));
+            }
+        }
+        TDEIO::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