NMEStyleCpp.h

Go to the documentation of this file.

/* License: new BSD license (see NME.h) */

#ifndef __NMEStyleCpp__
#define __NMEStyleCpp__

#if defined(UseNMECppException)
    // class NME is used without exceptions
#   undef UseNMECppException
#   include "NMECpp.h"
#   define UseNMECppException
    // still define class NMEError
#   include "NMEErrorCpp.h"
#else
#   include "NMECpp.h"
#endif

#include "NMEStyle.h"

class NMELinkHandler
{
    public:
        virtual void click(NMEConstText link, NMEInt linkLength) = 0;
};

class NMEStyle: public NME
{
    public:
        
        NMEStyle(): NME()
        {
            styleTable = NULL;
        }
        
        NMEStyle(char const *input, int inputLength = -1): NME(input, inputLength)
        {
            styleTable = NULL;
        }
        
        NMEStyle(NMEStyle const &nme): NME(nme)
        {
            unicodeStyleOffsets = nme.unicodeStyleOffsets;
            if (nme.styleTable)
            {
                format.parHookFun = format.spanHookFun = NMEStyleSpanHook;
                styleTableSize = nme.styleTableSize;
                styleTable = (NMEStyleTable *) new char[styleTableSize];
                NMEStyleInit(styleTable, styleTableSize,
                        unicodeStyleOffsets);
                styleTable->n = nme.styleTable->n;
                int i;
                for (i = 0; i < styleTable->n; i++)
                    styleTable->span[i] = nme.styleTable->span[i];
                format.hookData = (void *)styleTable;
            }
            else
                styleTable = NULL;
        }
        
        ~NMEStyle()
        {
            if (styleTable)
                delete [] (char *)styleTable;
        }
        
        NMEStyle operator = (NMEStyle const &nme)
        {
            if (this != &nme)
            {
                NME::operator = (nme);
                if (styleTable)
                    delete [] (char *)styleTable;
                if (nme.styleTable)
                {
                    format.parHookFun = format.spanHookFun = NMEStyleSpanHook;
                    styleTableSize = nme.styleTableSize;
                    styleTable = (NMEStyleTable *) new char[styleTableSize];
                    NMEStyleInit(styleTable, styleTableSize,
                            unicodeStyleOffsets);
                    styleTable->n = nme.styleTable->n;
                    int i;
                    for (i = 0; i < styleTable->n; i++)
                        styleTable->span[i] = nme.styleTable->span[i];
                    format.hookData = (void *)styleTable;
                }
                else
                    styleTable = NULL;
            }
            return *this;
        }
        
        void setUnicodeStyleOffsets(bool unicodeStyleOffsets = true)
        {
            this->unicodeStyleOffsets = unicodeStyleOffsets;
        }
        
        NMEErr getOutput(NMEConstText *output, NMEInt *outputLength = NULL)
        {
            if (!styleTable)
            {
                format.parHookFun = format.spanHookFun = NMEStyleSpanHook;
                styleTableSize = sizeof(NMEStyleTable) + inputLength;
                styleTable = (NMEStyleTable *) new char[styleTableSize];
                NMEStyleInit(styleTable, styleTableSize,
                        unicodeStyleOffsets);
                format.hookData = (void *)styleTable;
            }
            
            for (;;)
            {
                NMEErr err = NME::getOutput(output, outputLength);
                if (err == kNMEErrOk)
                    break;
                else if (err == (NMEErr)kNMEErrStyleTableTooSmall)
                {
                    if (styleTableSize >= 65536 + 10 * inputLength)
#if defined(UseNMECppException)
                        throw NMEError((NMEErr)kNMEErrStyleTableTooSmall);
#else
                        return (NMEErr)kNMEErrStyleTableTooSmall;
#endif
                    delete [] (char *)styleTable;
                    styleTableSize *= 2;
                    styleTable = (NMEStyleTable *) new char[styleTableSize];
                    NMEStyleInit(styleTable, styleTableSize,
                            unicodeStyleOffsets);
                    format.hookData = (void *)styleTable;
                }
                else
#if defined(UseNMECppException)
                    throw NMEError(err);
#else
                    return err;
#endif
            }
            
            return kNMEErrOk;
        }
        
        NMEStyleTable const *getStyleTable()
        {
            // parse input if not done yet
            if (!output)
                if (getOutput(NULL) != kNMEErrOk)   // ignore output
                {
                    // getOutput has allocated styleTable; reset it
                    NMEStyleInit(styleTable, styleTableSize,
                            unicodeStyleOffsets);
                    return NULL;
                }
            return styleTable;
        }
        
        NMEBoolean handleLinkClick(NMEInt offset, NMELinkHandler *handler)
        {
            // check table
            if (!styleTable)
                (void)getOutput(NULL);
            if (styleTable)
            {
                NMEInt i;
                
                for (i = 0; i < styleTable->n; i++)
                    if (styleTable->span[i].style == kNMEStyleCharLink
                            && offset >= styleTable->span[i].begin
                            && offset < styleTable->span[i].end)
                    {
                        if (handler)
                            handler->click(input + styleTable->span[i].linkOffset,
                                    styleTable->span[i].linkLength);
                        return TRUE;
                    }
            }
            
            return FALSE;
        }
        
    private:
        
        bool unicodeStyleOffsets;
        NMEStyleTable *styleTable;
        NMEInt styleTableSize;
};

#endif