qfontmanager_qws.h Include File

Home | All Classes | Main Classes | Annotated | Grouped Classes | Functions |

# qfontmanager_qws.h

This is the verbatim text of the qfontmanager_qws.h include file. It is provided only for illustration; the copyright remains with Trolltech.

    /****************************************************************************
    ** $Id: qt/qfontmanager_qws.h   3.3.8   edited Jan 11 14:38 $
    **
    ** Definition of font rendering infrastructure for Embedded TQt
    **
    ** Created : 940721
    **
    ** Copyright (C) 1992-2007 Trolltech ASA.  All rights reserved.
    **
    ** This file is part of the kernel module of the TQt GUI Toolkit.
    **
    ** This file may be used under the terms of the GNU General Public
    ** License versions 2.0 or 3.0 as published by the Free Software
    ** Foundation and appearing in the file LICENSE.GPL included in the
    ** packaging of this file. Alternatively you may (at your option) use any
    ** later version of the GNU General Public License if such license has
    ** been publicly approved by Trolltech ASA (or its successors, if any)
    ** and the KDE Free TQt Foundation.
    **
    ** Please review the following information to ensure GNU General
    ** Public Licensing requirements will be met:
    ** http://trolltech.com/products/qt/licenses/licensing/opensource/.
    ** If you are unsure which license is appropriate for your use, please
    ** review the following information:
    ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
    ** or contact the sales department at sales@trolltech.com.
    **
    ** Licensees holding valid TQt Commercial licenses may use this file in
    ** accordance with the TQt Commercial License Agreement provided with
    ** the Software.
    **
    ** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
    ** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
    ** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
    ** herein.
    **
    **********************************************************************/

    #ifndef TQFONTMANAGER_QWS_H
    #define TQFONTMANAGER_QWS_H

    #ifndef QT_H
    #include "ntqfont.h"
    #include "ntqptrlist.h"
    #include <private/qtextengine_p.h>
    #endif // QT_H

    // These are stored in the shared memory segment in front of their
    // data, and indexed at the start of the segment

    // This needs to be a multiple of 64 bits

    class TQFontDef;

    class TQ_PACKED TQGlyphMetrics {

    public:
        TQ_UINT8 linestep;
        TQ_UINT8 width;
        TQ_UINT8 height;
        TQ_UINT8 flags;

        TQ_INT8 bearingx;      // Difference from pen position to glyph's left bbox
        TQ_UINT8 advance;       // Difference between pen positions
        TQ_INT8 bearingy;      // Used for putting characters on baseline

        TQ_INT8 reserved;      // Do not use

        // Flags:
        // RendererOwnsData - the renderer is responsible for glyph data
        //                    memory deletion otherwise TQGlyphTree must
        //                    delete [] the data when the glyph is deleted.
        enum Flags { RendererOwnsData=0x01 };
    };

    class TQGlyph {
    public:
        TQGlyph() { metrics=0; data=0; }
        TQGlyph(TQGlyphMetrics* m, uchar* d) :
    	metrics(m), data(d) { }
        ~TQGlyph() {}

        TQGlyphMetrics* metrics;
        uchar* data;
    };

    class TQFontFactory;
    class TQDiskFont;

    // This is a particular font instance at a particular resolution
    // e.g. Truetype Times, 10 point. There's only one of these though;
    // we want to share generated glyphs

    class TQRenderedFont {

    public:

        // Normal font-type is monochrome; glyph data is a
        //   bitmap, which doesn't use much memory

        // Initialise for name A, renderer B, font type C, D glyphs

        TQRenderedFont(TQDiskFont *,const TQFontDef&);
        virtual ~TQRenderedFont();

        TQFontDef fontDef() const;

        int refcount;

        int ptsize;

        bool italic;
        unsigned int weight;

        void ref() { refcount++; }
        bool deref() { refcount--; return refcount==0; }

        bool match(const TQFontDef &);

        TQDiskFont* diskfont;
        int fascent,fdescent;
        int fleftbearing,frightbearing;
        int fmaxwidth;
        int fleading;
        int funderlinepos;
        int funderlinewidth;
        bool smooth;
        int maxchar;

        int ascent() { return fascent; }
        int descent() { return fdescent; }
        int width(int);
        int width( const TQString&, int =-1 );
        int leftBearing(int);
        int rightBearing(int);

        // Calling any of these can trigger a full-font metrics check
        // which can be expensive
        int minLeftBearing();
        int minRightBearing();
        int maxWidth();

        virtual bool inFont(glyph_t g) const=0;
        virtual TQGlyph render(glyph_t g)=0;

    private:

    };

    // Keeps track of available renderers and which font is which

    class TQDiskFontPrivate {};

    class TQDiskFont {

    public:
        TQDiskFont(TQFontFactory *f, const TQString& n, bool i, int w, int s,
    	      const TQString &fl, const TQString& fi) :
    	factory(f), name(n), italic(i), weight(w), size(s), flags(fl), file(fi)
        {
    	loaded=false;
    	p=0;
        }

        TQRenderedFont* load(const TQFontDef &);

        TQFontDef fontDef() const;

        TQFontFactory *factory;
        TQString name;
        bool italic;
        int weight;
        int size;
        TQString flags;
        TQString file;
        bool loaded;

        TQDiskFontPrivate * p;
    };

    class TQCachePolicy {

    public:

        virtual void cache(TQRenderedFont *)=0;
        virtual void uncache(TQRenderedFont *)=0;

    };

    // Exposed here so the default policy can be reset

    class TQDefaultCachePolicy : public TQCachePolicy {

    public:

        virtual void cache(TQRenderedFont *);
        virtual void uncache(TQRenderedFont *);

    };

    class TQFontManager {

    public:

        TQPtrList<TQFontFactory> factories;
        TQPtrList<TQRenderedFont> cachedfonts;
        TQPtrList<TQDiskFont> diskfonts;

        TQFontManager();
        ~TQFontManager();

        // Font definition, type and color
        TQDiskFont * get(const TQFontDef &);

        static int cmpFontDef(const TQFontDef & goal, const TQFontDef & choice);

        static void initialize();
        static void cleanup();

        void setPolicy(TQCachePolicy *);

        void cache(TQRenderedFont * f) { policy->cache(f); }
        void uncache(TQRenderedFont * f) { policy->uncache(f); }
        TQRenderedFont * getCached(const TQFontDef &);

    private:

        TQCachePolicy * policy;

    };

    class TQFontFactory {

    public:

        TQFontFactory() {}
        virtual ~TQFontFactory() {}

        virtual TQRenderedFont * get(const TQFontDef &,TQDiskFont *)=0;
        virtual void load(TQDiskFont *) const=0;
        virtual void unload(TQDiskFont *) {}
        virtual TQString name()=0;
    };

    void tqt_init_fonts();

    extern TQFontManager * qt_fontmanager;

    #endif