ttcr.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include <sft.hxx>
#include <vector>
 
namespace vcl
{
class TrueTypeTable;
struct tdata_loca;
struct table_cmap;
struct TableEntry;
 
 
/* TrueType data types */
    typedef struct {
        sal_uInt16 aw;
        sal_Int16  lsb;
    } longHorMetrics;
 
    enum TTCRErrCodes {
        TTCR_OK,                        
        TTCR_ZEROGLYPHS,                
        TTCR_UNKNOWN,                   
        TTCR_NONAMES,                   
        TTCR_NAMETOOLONG,               
        TTCR_POSTFORMAT                 
    };
 
    class TrueTypeCreator {
    public:
        TrueTypeCreator(sal_uInt32 tag);
        ~TrueTypeCreator();
        void AddTable(std::unique_ptr<TrueTypeTable> table);
        void RemoveTable(sal_uInt32 tag);
        SFErrCodes StreamToMemory(std::vector<sal_uInt8>& rOutBuffer);
 
    private:
        TrueTypeTable *FindTable(sal_uInt32 tag);
        void ProcessTables();
 
        sal_uInt32 m_tag;                                     
        std::vector<std::unique_ptr<TrueTypeTable>> m_tables; 
    };
 
    /* A generic base class for all TrueType tables */
    class TrueTypeTable {
    protected:
        TrueTypeTable(sal_uInt32 tag_) : m_tag(tag_) {}
 
    public:
        virtual ~TrueTypeTable();
 
        virtual int GetRawData(TableEntry*) = 0;
 
        sal_uInt32  m_tag = 0;                       /* table tag                                                */
        std::unique_ptr<sal_uInt8[]> m_rawdata;      /* raw data allocated by GetRawData_*()                     */
    };
 
    class TrueTypeTableGeneric : public TrueTypeTable
    {
    public:
        TrueTypeTableGeneric(sal_uInt32 tag,
                        sal_uInt32 nbytes,
                        const sal_uInt8* ptr);
        TrueTypeTableGeneric(sal_uInt32 tag,
                        sal_uInt32 nbytes,
                        std::unique_ptr<sal_uInt8[]> ptr);
        virtual ~TrueTypeTableGeneric() override;
        virtual int GetRawData(TableEntry*) override;
    private:
        sal_uInt32 m_nbytes;
        std::unique_ptr<sal_uInt8[]> m_ptr;
    };
 
    class TrueTypeTableHead : public TrueTypeTable
    {
    public:
        TrueTypeTableHead(sal_uInt32 fontRevision,
                         sal_uInt16 flags,
                         sal_uInt16 unitsPerEm,
                         const sal_uInt8  *created,
                         sal_uInt16 macStyle,
                         sal_uInt16 lowestRecPPEM,
                         sal_Int16  fontDirectionHint);
        virtual ~TrueTypeTableHead() override;
        virtual int GetRawData(TableEntry*) override;
 
        std::unique_ptr<sal_uInt8[]> m_head;
    };
 
    class TrueTypeTableHhea : public TrueTypeTable
    {
    public:
        TrueTypeTableHhea(sal_Int16  ascender,
                                         sal_Int16  descender,
                                         sal_Int16  linegap,
                                         sal_Int16  caretSlopeRise,
                                         sal_Int16  caretSlopeRun);
        virtual ~TrueTypeTableHhea() override;
        virtual int GetRawData(TableEntry*) override;
 
        std::unique_ptr<sal_uInt8[]> m_hhea;
    };
 
    class TrueTypeTableLoca : public TrueTypeTable
    {
    public:
        TrueTypeTableLoca();
        virtual ~TrueTypeTableLoca() override;
        virtual int GetRawData(TableEntry*) override;
 
        std::unique_ptr<tdata_loca> m_loca;
    };
 
    class TrueTypeTableMaxp : public TrueTypeTable
    {
    public:
        TrueTypeTableMaxp(const sal_uInt8* maxp, int size);
        virtual ~TrueTypeTableMaxp() override;
        virtual int GetRawData(TableEntry*) override;
 
        std::unique_ptr<sal_uInt8[]> m_maxp;
    };
 
    class TrueTypeTableGlyf : public TrueTypeTable
    {
    public:
        TrueTypeTableGlyf();
        virtual ~TrueTypeTableGlyf() override;
        virtual int GetRawData(TableEntry*) override;
 
        sal_uInt32 glyfAdd(std::unique_ptr<GlyphData> glyphdata, AbstractTrueTypeFont *fnt);
 
        sal_uInt32 glyfCount() { return m_list.size(); }
 
        std::vector<std::unique_ptr<GlyphData>> m_list;
    };
 
    class TrueTypeTableCmap : public TrueTypeTable
    {
    public:
        TrueTypeTableCmap();
        virtual ~TrueTypeTableCmap() override;
        virtual int GetRawData(TableEntry*) override;
 
        void cmapAdd(sal_uInt32 id, sal_uInt32 c, sal_uInt32 g);
 
    private:
        std::unique_ptr<table_cmap> m_cmap;
    };
 
    class TrueTypeTableName : public TrueTypeTable
    {
    public:
        TrueTypeTableName(std::vector<NameRecord> nr);
        virtual ~TrueTypeTableName() override;
        virtual int GetRawData(TableEntry*) override;
    private:
        std::vector<NameRecord> m_list;
    };
 
    class TrueTypeTablePost : public TrueTypeTable
    {
    public:
        TrueTypeTablePost(sal_Int32 format,
                     sal_Int32 italicAngle,
                     sal_Int16 underlinePosition,
                     sal_Int16 underlineThickness,
                     sal_uInt32 isFixedPitch);
        virtual ~TrueTypeTablePost() override;
        virtual int GetRawData(TableEntry*) override;
    private:
        sal_uInt32 m_format;
        sal_uInt32 m_italicAngle;
        sal_Int16  m_underlinePosition;
        sal_Int16  m_underlineThickness;
        sal_uInt32 m_isFixedPitch;
    };
 
} // namespace
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */