ciderpress/reformat/Teach.h

/*
 * CiderPress
 * Copyright (C) 2007 by faddenSoft, LLC.  All Rights Reserved.
 * See the file LICENSE for distribution terms.
 */
/*
 * Teach Text handling.
 */
#ifndef __LR_TEACH__
#define __LR_TEACH__

#include "ReformatBase.h"

/*
 * Reformat a generic IIgs text file.
 */
class ReformatGWP : public ReformatText {
public:
    ReformatGWP(void) {}
    virtual ~ReformatGWP(void) {}

    virtual void Examine(ReformatHolder* pHolder);
    virtual int Process(const ReformatHolder* pHolder,
        ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
        ReformatOutput* pOutput);
};

/*
 * Reformat a Teach file
 */
class ReformatTeach : public ReformatText {
public:
    ReformatTeach(void) {}
    virtual ~ReformatTeach(void) {}

    virtual void Examine(ReformatHolder* pHolder);
    virtual int Process(const ReformatHolder* pHolder,
        ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
        ReformatOutput* pOutput);

private:
};

/*
 * Class to hold the style block.
 *
 * The definition allows for an array of rulers, but in practice there
 * is no way to actually use more than one.  Because rulers are
 * variable-length, we take the easy road here and assume there's just
 * one.  To be safe, the interface pretends there could be more than one.
 */
class RStyleBlock {
public:
    RStyleBlock(void) : fpRulers(nil), fpStyles(nil), fpStyleItems(nil) {}
    virtual ~RStyleBlock(void) {
            delete[] fpRulers;
            delete[] fpStyles;
            delete[] fpStyleItems;
        }

    /* unpack the resource; returns false on failure */
    bool Create(const unsigned char* buf, long len);

    /*
     * Class representing a IIgs TERuler object.
     */
    class TERuler {
    public:
        TERuler(void) {}
        virtual ~TERuler(void) {}

        /* unpack the ruler; returns the #of bytes consumed */
        int Create(const unsigned char* buf, long len);

        typedef enum Justification {
            kJustLeft   = 0x0000,
            kJustRight  = 0xffff,
            kJustCenter = 0x0001,
            kJustFull   = 0x0002
        } Justification;

        Justification GetJustification(void) const {
            return (Justification) fJust;
        }

    private:
        enum {
            kMinLen = 0x12,
            kTabArrayEnd = 0xffff,
        };

        typedef struct TabItem {
            unsigned short  tabKind;    // must be $0000
            unsigned short  tabData;    // tab location, in pixels from left
        } TabItem;

        unsigned short  fLeftMargin;    // pixel indent, except para start
        unsigned short  fLeftIndent;    // pixel indent, for para start
        unsigned short  fRightMargin;   // maximum line len, in pixels
        unsigned short  fJust;          // enum Justification
        unsigned short  fExtraLS;       // extra line spacing, in pixels
        unsigned short  fFlags;         // reserved
        unsigned long   fUserData;
        unsigned short  fTabType;       // 0=none, 1=interval, 2=irregular
        // array of TabItem appears here for fTabType==2
        unsigned short  fTabTerminator; // present for fTabType==1 or 2
    };

    /*
     * Class representing a IIgs TEStyle object.
     */
    class TEStyle {
    public:
        TEStyle(void) {}
        virtual ~TEStyle(void) {}

        /* unpack the style; returns the #of bytes consumed */
        void Create(const unsigned char* buf);

        /* Apple IIgs font family number */
        unsigned short GetFontFamily(void) const {
            return (unsigned short) fFontID;
        }
        /* font size, in points */
        int GetFontSize(void) const {
            return (fFontID >> 24) & 0xff;
        }
        /* return QDII text style */
        unsigned char GetTextStyle(void) const {
            return (unsigned char) ((fFontID >> 16) & 0xff);
        }
        /* return QDII text color */
        unsigned short GetTextColor(void) const { return fForeColor; }

        /* individual text style getters */
        //bool IsBold(void) const { return (GetTextStyle() & kBold) != 0; }
        //bool IsItalic(void) const { return (GetTextStyle() & kItalic) != 0; }
        //bool IsUnderline(void) const { return (GetTextStyle() & kUnderline) != 0; }

        enum { kDataLen = 12 };

    private:
        unsigned long   fFontID;
        unsigned short  fForeColor;
        unsigned short  fBackColor;
        unsigned long   fUserData;
    };

    /*
     * Class representing a IIgs StyleItem object.
     */
    class StyleItem {
    public:
        StyleItem(void) {}
        virtual ~StyleItem(void) {}

        /* unpack the item */
        void Create(const unsigned char* buf);

        unsigned long GetLength(void) const { return fLength; }
        unsigned long GetOffset(void) const { return fOffset; }
        int GetStyleIndex(void) const {
            /* MSVC++6.0 won't let me use TEStyle::kDataLen here */
            return fOffset / 12;
        }

        enum {
            kDataLen = 8,
            kUnusedItem = 0xffffffff,   // in fLength field
        };

    private:
        unsigned long   fLength;    // #of characters affected by this style
        unsigned long   fOffset;    // offset in bytes into TEStyle list
    };

    enum {
        kExpectedVersion = 0,
        kMinLen = 4*3 +2,
    };


    /*
     * More RStyleBlock declarations.
     */
    TERuler* GetRuler(int idx) {
        assert(idx >= 0 && idx < fNumRulers);
        return &fpRulers[idx];
    }
    TEStyle* GetStyle(int idx) {
        assert(idx >= 0 && idx < fNumStyles);
        return &fpStyles[idx];
    }
    int GetNumStyleItems(void) const { return fNumStyleItems; }
    StyleItem* GetStyleItem(int idx) {
        assert(idx >= 0 && idx < fNumStyleItems);
        return &fpStyleItems[idx];
    }

private:
    int     fNumRulers;
    int     fNumStyles;
    int     fNumStyleItems;

    TERuler*    fpRulers;
    TEStyle*    fpStyles;
    StyleItem*  fpStyleItems;
};


#endif /*__LR_TEACH__*/