/*
    Copyright (C) 2000, S.R.Haque <shaheedhaque@hotmail.com>.
    This file is part of the KDE project

    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.

DESCRIPTION
*/

#include <kdebug.h>
#include <myfile.h>
#include <powerpoint.h>

const int Powerpoint::s_area = 30512;

Powerpoint::Powerpoint()
{
	mEditOffset = 0;
	m_pptSlide = 0;
}

Powerpoint::~Powerpoint()
{
    m_persistentReferences.clear();
    //m_slides.clear();
}

void Powerpoint::invokeHandler(
    Header &op,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    typedef void (Powerpoint::*method)(Header &op, TQ_UINT32 bytes, TQDataStream &operands);

    typedef struct
    {
        const char *name;
        TQ_UINT16 opcode;
        method handler;
    } opcodeEntry;

    static const opcodeEntry funcTab[] =
    {
        { "ANIMATIONINFO",              4116,   0 /* &Powerpoint::opAnimationInfo */ },
        { "ANIMATIONINFOATOM",          4081,   0 /* &Powerpoint::opAnimationInfoAtom */ },
        { "ARRAYELEMENTATOM",           2030,   0 /* &Powerpoint::opArrayElementAtom */ },
        { "BASETEXTPROPATOM",           4002,   0 /* &Powerpoint::opBaseTextPropAtom */ },
        { "BINARYTAGDATA",              5003,   0 /* &Powerpoint::opBinaryTagData */ },
        { "BOOKMARKCOLLECTION",         2019,   0 /* &Powerpoint::opBookmarkCollection */ },
        { "BOOKMARKENTITYATOM",         4048,   0 /* &Powerpoint::opBookmarkEntityAtom */ },
        { "BOOKMARKSEEDATOM",           2025,   0 /* &Powerpoint::opBookmarkSeedAtom */ },
        { "CHARFORMATATOM",             4066,   0 /* &Powerpoint::opCharFormatAtom */ },
        { "CLIENTSIGNAL1",              6,      0 /* &Powerpoint::opClientSignal1 */ },
        { "CLIENTSIGNAL2",              7,      0 /* &Powerpoint::opClientSignal2 */ },
        { "COLORSCHEMEATOM",            2032,   &Powerpoint::opColorSchemeAtom },
        { "COREPICT",                   4037,   0 /* &Powerpoint::opCorePict */ },
        { "COREPICTATOM",               4038,   0 /* &Powerpoint::opCorePictAtom */ },
        { "CSTRING",                    4026,   &Powerpoint::opCString },
        { "CURRENTUSERATOM",            4086,   &Powerpoint::opCurrentUserAtom },
        { "DATETIMEMCATOM",             4087,   0 /* &Powerpoint::opDateTimeMCAtom */ },
        { "DEFAULTRULERATOM",           4011,   0 /* &Powerpoint::opDefaultRulerAtom */ },
        { "DOCROUTINGSLIP",             1030,   0 /* &Powerpoint::opDocRoutingSlip */ },
        { "DOCUMENT",                   1000,   &Powerpoint::opDocument },
        { "DOCUMENTATOM",               1001,   &Powerpoint::opDocumentAtom },
        { "DOCVIEWINFO",                1014,   0 /* &Powerpoint::opDocViewInfo */ },
        { "EMFORMATATOM",               4065,   0 /* &Powerpoint::opEmFormatAtom */ },
        { "ENDDOCUMENT",                1002,   &Powerpoint::opEndDocument },
        { "ENVIRONMENT",                1010,   &Powerpoint::opEnvironment },
        { "EXAVIMOVIE",                 4102,   0 /* &Powerpoint::opExAviMovie */ },
        { "EXCDAUDIO",                  4110,   0 /* &Powerpoint::opExCDAudio */ },
        { "EXCDAUDIOATOM",              4114,   0 /* &Powerpoint::opExCDAudioAtom */ },
        { "EXCONTROL",                  4078,   0 /* &Powerpoint::opExControl */ },
        { "EXCONTROLATOM",              4091,   0 /* &Powerpoint::opExControlAtom */ },
        { "EXEMBED",                    4044,   &Powerpoint::opExEmbed },
        { "EXEMBEDATOM",                4045,   &Powerpoint::opExEmbedAtom },
        { "EXHYPERLINK",                4055,   0 /* &Powerpoint::opExHyperlink */ },
        { "EXHYPERLINKATOM",            4051,   0 /* &Powerpoint::opExHyperlinkAtom */ },
        { "EXLINK",                     4046,   0 /* &Powerpoint::opExLink */ },
        { "EXLINKATOM",                 4049,   0 /* &Powerpoint::opExLinkAtom */ },
        { "EXLINKATOM_OLD",             4047,   0 /* &Powerpoint::opExLinkAtom_old */ },
        { "EXMCIMOVIE",                 4103,   0 /* &Powerpoint::opExMCIMovie */ },
        { "EXMEDIAATOM",                4100,   0 /* &Powerpoint::opExMediaAtom */ },
        { "EXMIDIAUDIO",                4109,   0 /* &Powerpoint::opExMIDIAudio */ },
        { "EXOBJLIST",                  1033,   &Powerpoint::opExObjList },
        { "EXOBJLISTATOM",              1034,   &Powerpoint::opExObjListAtom },
        { "EXOBJREFATOM",               3009,   &Powerpoint::opExObjRefAtom },
        { "EXOLEOBJ",                   4034,   &Powerpoint::opExOleObj },
        { "EXOLEOBJATOM",               4035,   &Powerpoint::opExOleObjAtom },
        { "EXOLEOBJSTG",                4113,   &Powerpoint::opExOleObjStg },
        { "EXPLAIN",                    4053,   0 /* &Powerpoint::opExPlain */ },
        { "EXPLAINATOM",                4039,   0 /* &Powerpoint::opExPlainAtom */ },
        { "EXPLAINLINK",                4054,   0 /* &Powerpoint::opExPlainLink */ },
        { "EXPLAINLINKATOM",            4036,   0 /* &Powerpoint::opExPlainLinkAtom */ },
        { "EXQUICKTIME",                4073,   0 /* &Powerpoint::opExQuickTime */ },
        { "EXQUICKTIMEMOVIE",           4074,   0 /* &Powerpoint::opExQuickTimeMovie */ },
        { "EXQUICKTIMEMOVIEDATA",       4075,   0 /* &Powerpoint::opExQuickTimeMovieData */ },
        { "EXSUBSCRIPTION",             4076,   0 /* &Powerpoint::opExSubscription */ },
        { "EXSUBSCRIPTIONSECTION",      4077,   0 /* &Powerpoint::opExSubscriptionSection */ },
        { "EXTERNALOBJECT",             4027,   0 /* &Powerpoint::opExternalObject */ },
        { "EXVIDEO",                    4101,   0 /* &Powerpoint::opExVideo */ },
        { "EXWAVAUDIOEMBEDDED",         4111,   0 /* &Powerpoint::opExWAVAudioEmbedded */ },
        { "EXWAVAUDIOEMBEDDEDATOM",     4115,   0 /* &Powerpoint::opExWAVAudioEmbeddedAtom */ },
        { "EXWAVAUDIOLINK",             4112,   0 /* &Powerpoint::opExWAVAudioLink */ },
        { "FONTCOLLECTION",             2005,   &Powerpoint::opFontCollection },
        { "FONTEMBEDDATA",              4024,   0 /* &Powerpoint::opFontEmbedData */ },
        { "FONTENTITYATOM",             4023,   &Powerpoint::opFontEntityAtom },
        { "FOOTERMCATOM",               4090,   0 /* &Powerpoint::opFooterMCAtom */ },
        { "GENERICDATEMCATOM",          4088,   0 /* &Powerpoint::opGenericDateMCAtom */ },
        { "GLINEATOM",                  10004,  0 /* &Powerpoint::opGlineAtom */ },
        { "GLPOINTATOM",                10003,  0 /* &Powerpoint::opGLPointAtom */ },
        { "GPOINTATOM",                 3034,   0 /* &Powerpoint::opGpointAtom */ },
        { "GRATIOATOM",                 3031,   0 /* &Powerpoint::opGratioAtom */ },
        { "GRCOLOR",                    3020,   0 /* &Powerpoint::opGrColor */ },
        { "GRCOLORATOM",                10002,  0 /* &Powerpoint::opGrColorAtom */ },
        { "GRECTATOM",                  3025,   0 /* &Powerpoint::opGrectAtom */ },
        { "GSCALING",                   3032,   0 /* &Powerpoint::opGscaling */ },
        { "GSCALINGATOM",               10001,  0 /* &Powerpoint::opGscalingAtom */ },
        { "GUIDEATOM",                  1019,   0 /* &Powerpoint::opGuideAtom */ },
        { "GUIDELIST",                  2026,   0 /* &Powerpoint::opGuideList */ },
        { "HANDOUT",                    4041,   0 /* &Powerpoint::opHandout */ },
        { "HEADERMCATOM",               4089,   0 /* &Powerpoint::opHeaderMCAtom */ },
        { "HEADERSFOOTERS",             4057,   &Powerpoint::opHeadersFooters },
        { "HEADERSFOOTERSATOM",         4058,   &Powerpoint::opHeadersFootersAtom },
        { "INT4ARRAYATOM",              2031,   0 /* &Powerpoint::opInt4ArrayAtom */ },
        { "INTERACTIVEINFO",            4082,   0 /* &Powerpoint::opInteractiveInfo */ },
        { "INTERACTIVEINFOATOM",        4083,   0 /* &Powerpoint::opInteractiveInfoAtom */ },
        { "IRRATOM",                    2,      0 /* &Powerpoint::opIRRAtom */ },
        { "LIST",                       2000,   &Powerpoint::opList },
        { "LISTPLACEHOLDER",            2017,   0 /* &Powerpoint::opListPlaceholder */ },
        { "MAINMASTER",                 1016,   &Powerpoint::opMainMaster },
        { "MASTERTEXT",                 4068,   0 /* &Powerpoint::opMasterText */ },
        { "METAFILE",                   4033,   0 /* &Powerpoint::opMetaFile */ },
        { "NAMEDSHOW",                  1041,   0 /* &Powerpoint::opNamedShow */ },
        { "NAMEDSHOWS",                 1040,   0 /* &Powerpoint::opNamedShows */ },
        { "NAMEDSHOWSLIDES",            1042,   0 /* &Powerpoint::opNamedShowSlides */ },
        { "NOTES",                      1008,   &Powerpoint::opNotes },
        { "NOTESATOM",                  1009,   &Powerpoint::opNotesAtom },
        { "OEPLACEHOLDERATOM",          3011,   0 /* &Powerpoint::opOEPlaceholderAtom */ },
        { "OESHAPE",                    3008,   0 /* &Powerpoint::opOEShape */ },
        { "OESHAPEATOM",                3035,   0 /* &Powerpoint::opOEShapeAtom */ },
        { "OUTLINETEXTREFATOM",         3998,   0 /* &Powerpoint::opOutlineTextRefAtom */ },
        { "OUTLINEVIEWINFO",            1031,   &Powerpoint::opOutlineViewInfo },
        { "PARAFORMATATOM",             4067,   0 /* &Powerpoint::opParaFormatAtom */ },
        { "PERSISTPTRFULLBLOCK",        6001,   0 /* &Powerpoint::opPersistPtrFullBlock */ },
        { "PERSISTPTRINCREMENTALBLOCK", 6002,   &Powerpoint::opPersistPtrIncrementalBlock },
        { "POWERPOINTSTATEINFOATOM",    10,     0 /* &Powerpoint::opPowerPointStateInfoAtom */ },
        { "PPDRAWING",                  1036,   &Powerpoint::opPPDrawing },
        { "PPDRAWINGGROUP",             1035,   &Powerpoint::opPPDrawingGroup },
        { "PRINTOPTIONS",               6000,   0 /* &Powerpoint::opPrintOptions */ },
        { "PROGBINARYTAG",              5002,   0 /* &Powerpoint::opProgBinaryTag */ },
        { "PROGSTRINGTAG",              5001,   0 /* &Powerpoint::opProgStringTag */ },
        { "PROGTAGS",                   5000,   0 /* &Powerpoint::opProgTags */ },
        { "PSS",                        3,      0 /* &Powerpoint::opPSS */ },
        { "RECOLORENTRYATOM",           4062,   0 /* &Powerpoint::opRecolorEntryAtom */ },
        { "RECOLORINFOATOM",            4071,   0 /* &Powerpoint::opRecolorInfoAtom */ },
        { "RTFDATETIMEMCATOM",          4117,   0 /* &Powerpoint::opRTFDateTimeMCAtom */ },
        { "RULERINDENTATOM",            10000,  0 /* &Powerpoint::opRulerIndentAtom */ },
        { "RUNARRAY",                   2028,   0 /* &Powerpoint::opRunArray */ },
        { "RUNARRAYATOM",               2029,   0 /* &Powerpoint::opRunArrayAtom */ },
        { "SCHEME",                     1012,   0 /* &Powerpoint::opScheme */ },
        { "SCHEMEATOM",                 1013,   0 /* &Powerpoint::opSchemeAtom */ },
        { "SLIDE",                      1006,   &Powerpoint::opSlide },
        { "SLIDEATOM",                  1007,   &Powerpoint::opSlideAtom },
        { "SLIDEBASE",                  1004,   0 /* &Powerpoint::opSlideBase */ },
        { "SLIDEBASEATOM",              1005,   0 /* &Powerpoint::opSlideBaseAtom */ },
        { "SLIDELIST",                  4084,   0 /* &Powerpoint::opSlideList */ },
        { "SLIDELISTWITHTEXT",          4080,   &Powerpoint::opSlideListWithText },
        { "SLIDENUMBERMCATOM",          4056,   0 /* &Powerpoint::opSlideNumberMCAtom */ },
        { "SLIDEPERSIST",               1003,   0 /* &Powerpoint::opSlidePersist */ },
        { "SLIDEPERSISTATOM",           1011,   &Powerpoint::opSlidePersistAtom },
        { "SLIDEVIEWINFO",              1018,   &Powerpoint::opSlideViewInfo },
        { "SLIDEVIEWINFOATOM",          1022,   0 /* &Powerpoint::opSlideViewInfoAtom */ },
        { "SORTERVIEWINFO",             1032,   0 /* &Powerpoint::opSorterViewInfo */ },
        { "SOUND",                      2022,   0 /* &Powerpoint::opSound */ },
        { "SOUNDCOLLATOM",              2021,   0 /* &Powerpoint::opSoundCollAtom */ },
        { "SOUNDCOLLECTION",            2020,   0 /* &Powerpoint::opSoundCollection */ },
        { "SOUNDDATA",                  2023,   0 /* &Powerpoint::opSoundData */ },
        { "SRKINSOKU",                  4040,   &Powerpoint::opSrKinsoku },
        { "SRKINSOKUATOM",              4050,   0 /* &Powerpoint::opSrKinsokuAtom */ },
        { "SSDOCINFOATOM",              1025,   &Powerpoint::opSSDocInfoAtom },
        { "SSLIDELAYOUTATOM",           1015,   &Powerpoint::opSSSlideLayoutAtom },
        { "SSSLIDEINFOATOM",            1017,   0 /* &Powerpoint::opSSSlideInfoAtom */ },
        { "STYLETEXTPROPATOM",          4001,   &Powerpoint::opStyleTextPropAtom },
        { "SUBCONTAINERCOMPLETED",      1,      0 /* &Powerpoint::opSubContainerCompleted */ },
        { "SUBCONTAINEREXCEPTION",      4,      0 /* &Powerpoint::opSubContainerException */ },
        { "SUMMARY",                    1026,   0 /* &Powerpoint::opSummary */ },
        { "TEXTBOOKMARKATOM",           4007,   0 /* &Powerpoint::opTextBookmarkAtom */ },
        { "TEXTBYTESATOM",              4008,   &Powerpoint::opTextBytesAtom },
        { "TEXTCHARSATOM",              4000,   &Powerpoint::opTextCharsAtom },
        { "TEXTHEADERATOM",             3999,   &Powerpoint::opTextHeaderAtom },
        { "TEXTRULERATOM",              4006,   0 /* &Powerpoint::opTextRulerAtom */ },
        { "TEXTSPECINFOATOM",           4010,   &Powerpoint::opTextSpecInfoAtom },
        { "TEXTURE",                    1027,   0 /* &Powerpoint::opTexture */ },
        { "TXCFSTYLEATOM",              4004,   0 /* &Powerpoint::opTxCFStyleAtom */ },
        { "TXINTERACTIVEINFOATOM",      4063,   0 /* &Powerpoint::opTxInteractiveInfoAtom */ },
        { "TXMASTERSTYLEATOM",          4003,   &Powerpoint::opTxMasterStyleAtom },
        { "TXPFSTYLEATOM",              4005,   0 /* &Powerpoint::opTxPFStyleAtom */ },
        { "TXSISTYLEATOM",              4009,   &Powerpoint::opTxSIStyleAtom },
        { "TYPEFACE",                   4025,   0 /* &Powerpoint::opTypeFace */ },
        { "USEREDITATOM",               4085,   &Powerpoint::opUserEditAtom },
        { "VBAINFO",                    1023,   &Powerpoint::opVBAInfo },
        { "VBAINFOATOM",                1024,   0 /* &Powerpoint::opVBAInfoAtom */ },
        { "VBASLIDEINFO",               1028,   0 /* &Powerpoint::opVBASlideInfo */ },
        { "VBASLIDEINFOATOM",           1029,   0 /* &Powerpoint::opVBASlideInfoAtom */ },
        { "VIEWINFO",                   1020,   0 /* &Powerpoint::opViewInfo */ },
        { "VIEWINFOATOM",               1021,   0 /* &Powerpoint::opViewInfoAtom */ },
        { NULL,                         0,      0 },
        { "MSOD",                       0,      &Powerpoint::opMsod }
    };
    unsigned i;
    method result;

    // Scan lookup table for operation.

    for (i = 0; funcTab[i].name; i++)
    {
        if (funcTab[i].opcode == op.type)
        {
            break;
        }
    }

    // Invoke handler.

    result = funcTab[i].handler;
    if (!result && (op.type >= 0xF000) && (0xFFFF >= op.type))
        result = funcTab[++i].handler;
    if (!result)
    {
        if (funcTab[i].name)
            kdWarning(s_area) << "invokeHandler: unsupported opcode: " <<
                funcTab[i].name <<
                " operands: " << bytes << endl;
        else
            kdWarning(s_area) << "invokeHandler: unsupported opcode: " <<
                op.type <<
                " operands: " << bytes << endl;

        // Skip data we cannot use.
        skip(bytes, operands);
    }
    else
    {
        kdDebug(s_area) << "invokeHandler: opcode: " << funcTab[i].name <<
            " operands: " << bytes << endl;

        // We don't invoke the handler directly on the incoming operands, but
        // via a temporary datastream. This adds overhead, but eliminates the
        // need for the individual handlers to read *exactly* the right amount
        // of data (thus speeding development, and possibly adding some
        // future-proofing).

        if (bytes)
        {
            TQByteArray *record = new TQByteArray(bytes);
            TQDataStream *body;

            operands.readRawBytes(record->data(), bytes);
            body = new TQDataStream(*record, IO_ReadOnly);
            body->setByteOrder(TQDataStream::LittleEndian);
            (this->*result)(op, bytes, *body);
            delete body;
            delete record;
        }
        else
        {
            TQDataStream *body = new TQDataStream();

            (this->*result)(op, bytes, *body);
            delete body;
        }
    }
}

bool Powerpoint::parse(
    myFile &mainStream,
    myFile &currentUser,
    myFile &pictures)
{
    unsigned i;

    m_mainStream = mainStream;
    m_pictures = pictures;
    m_documentRef = 0;
    m_documentRefFound = false;
    m_persistentReferences.clear();
    m_slideList.clear();
    m_editDepth = 0;

    // Find the slide references.

    m_pass = PASS_GET_SLIDE_REFERENCES;
    kdError(s_area) << "parseing step 1 walkRecord..." << endl;
    walkRecord(currentUser.length, currentUser.data);//get curren user information

    kdError(s_area) << "parseing step 2 walkReference..." << endl;
    //for(i = 0; i <= 2; i++)//walk the 2 slide atoms
    //{
    //	kdError(s_area) << "ref == :" << i <<endl;
	//walkReference(i);
    //}
    kdError(s_area) << "walking slide list!!!!.." << endl;
    if(mEditOffset != 0) walk(mEditOffset);
    else walkDocument();
    // We should have a complete list of slide persistent references.
    m_pass = PASS_GET_SLIDE_CONTENTS;
    kdError(s_area) << "TOTAL SLIDES XXxx: " << m_slideList.count() << endl;

     for (i = 0; i < m_slideList.count(); i++)
    {
        m_pptSlide = m_slideList.at(i);
        walkReference(i);
        gotSlide(*m_pptSlide);
    }

    return true;
}

void Powerpoint::opColorSchemeAtom(
    Header & /* op */,
    TQ_UINT32,
    TQDataStream &operands)
{
    struct
    {
        TQ_UINT32 background;
        TQ_UINT32 textAndLines;
        TQ_UINT32 shadows;
        TQ_UINT32 titleText;
        TQ_UINT32 fills;
        TQ_UINT32 accent;
        TQ_UINT32 accentAndHyperlink;
        TQ_UINT32 accentAndFollowedHyperlink;
    } data;

    operands >> data.background >> data.textAndLines >> data.shadows >>
        data.titleText >> data.fills >> data.accent >> data.accentAndHyperlink >>
        data.accentAndFollowedHyperlink;
}

//
// A Unicode String.
//
void Powerpoint::opCString(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    TQString value;
    unsigned i;

    for (i = 0; i < bytes / 2; i++)
    {
        TQ_UINT16 tmp;

        operands >> tmp;
        value += tmp;
    }
    kdDebug(s_area) << "value: " << value << endl;
}

void Powerpoint::opCurrentUserAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &operands)
{

    const TQ_UINT32 MAGIC_NUMBER = (TQ_UINT32)(-476987297);
    //unsigned i;

    operands >> mCurrentUserAtom.size >> mCurrentUserAtom.magic >> mCurrentUserAtom.offsetToCurrentEdit >>
        mCurrentUserAtom.lenUserName >> mCurrentUserAtom.docFileVersion >> mCurrentUserAtom.majorVersion >>
        mCurrentUserAtom.minorVersion;

    kdDebug(s_area) << "\nPSR_CurrentUserAtom:" <<
        "\n\tsize: " << mCurrentUserAtom.size <<
        "\n\tmagic: " << mCurrentUserAtom.magic <<
        "\n\toffsetToCurrentEdit: " << mCurrentUserAtom.offsetToCurrentEdit <<
        "\n\tlenUserName: " << mCurrentUserAtom.lenUserName <<
        "\n\tdocFileVersion: " << mCurrentUserAtom.docFileVersion <<
        "\n\tmajorVersion: " << mCurrentUserAtom.majorVersion <<
        "\n\tminorVersion: " << mCurrentUserAtom.minorVersion << endl;

    switch (m_pass)
    {
    case PASS_GET_SLIDE_REFERENCES:
        if (mCurrentUserAtom.size != 20)
        {
            kdError(s_area) << "invalid size: " << mCurrentUserAtom.size << endl;
        }
        if (mCurrentUserAtom.magic != MAGIC_NUMBER)
        {
            kdError(s_area) << "invalid magic number: " << mCurrentUserAtom.magic << endl;
        }
        if ((mCurrentUserAtom.docFileVersion != 1012) ||
            (mCurrentUserAtom.majorVersion != 3) ||
            (mCurrentUserAtom.minorVersion != 0))// ||
           // (data.release < 8) ||
           // (data.release > 10))
        {
            kdError(s_area) << "invalid version: " << mCurrentUserAtom.docFileVersion <<
                "." << mCurrentUserAtom.majorVersion <<
                "." << mCurrentUserAtom.minorVersion <<
                endl;
                //"." << data.release << endl;
        }

        // Now walk main stream starting at current edit point.

        walkRecord(mCurrentUserAtom.offsetToCurrentEdit);
        break;
    case PASS_GET_SLIDE_CONTENTS:
        break;
    };
}

void Powerpoint::opDocument(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opDocumentAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opEndDocument(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opEnvironment(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

//
// Contains an ExEmbedAtom and 3 CStrings (the menu name, the program id which
// unqiuely identifies the type of object, and the "paste special" name).
//
void Powerpoint::opExEmbed(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

//
// Information about an embedded object.
//
void Powerpoint::opExEmbedAtom(
    Header & /* op */,
    TQ_UINT32,
    TQDataStream &operands)
{
    struct
    {
        TQ_INT32 followColorScheme;
        TQ_UINT8 cantLockServerB;
        TQ_UINT8 noSizeToServerB;
        TQ_UINT8 isTable;
    } data;

    operands >> data.followColorScheme;
    operands >> data.cantLockServerB;
    operands >> data.noSizeToServerB;
    operands >> data.isTable;
}

void Powerpoint::opFontCollection(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opFontEntityAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opHeadersFooters(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opHeadersFootersAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opList(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opMainMaster(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opMsod(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    char *data;

    switch (m_pass)
    {
    case PASS_GET_SLIDE_REFERENCES:
        break;
    case PASS_GET_SLIDE_CONTENTS:
        data = new char[bytes];
        operands.readRawBytes((char *)data, bytes);
kdError() <<"       drgid: "<< m_pptSlide->getPsrReference() << endl;
        gotDrawing(m_pptSlide->getPsrReference(), "msod", bytes, data);
        delete [] data;
        break;
    };
}

void Powerpoint::opNotes(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opNotesAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &operands)
{
    struct
    {
        TQ_INT32 slideId;    // Id for the corresponding slide.
        TQ_UINT16 flags;
    } data;

    operands >> data.slideId >> data.flags;
}

//
// Contains an ExObjListAtom and a list of all objects in a document.
//
void Powerpoint::opExObjList(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

//
// Get the next unique identifier for OLE objects.
//
void Powerpoint::opExObjListAtom(
    Header & /* op */,
    TQ_UINT32,
    TQDataStream &operands)
{
    TQ_UINT32 objectSeedId;

    operands >> objectSeedId;
    kdDebug(s_area) << "next OLE obj id: " << objectSeedId << endl;
}

void Powerpoint::opExObjRefAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opExOleObj(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opExOleObjAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &operands)
{
    struct
    {
        TQ_UINT32 drawAspect;
        TQ_INT32 type;
        TQ_INT32 objID;
        TQ_INT32 subType;
        TQ_INT8 isBlank;
    } data;

    operands >> data.drawAspect;
    operands >> data.type;
    operands >> data.objID;
    operands >> data.subType;
    operands >> data.isBlank;
    kdDebug(s_area) << ((data.type == 0) ? "embedded " : "linked ") <<
        "OLE obj id: " << data.objID << endl;
}

void Powerpoint::opExOleObjStg(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opOutlineViewInfo(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opPersistPtrIncrementalBlock2(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
    //PSR_UserEditAtom userEdit;
    //TQ_INT16 offsetToEdit = mCurrentUserAtom.offsetToCurrentEdit;

    /* huh?
    while(0 < offsetToEdit)
    {

    }*/

//       mpLastUserEditAtom;

}

void Powerpoint::opPersistPtrIncrementalBlock(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    struct
    {
        union
        {
            TQ_UINT32 info;
            struct
            {
                TQ_UINT32 offsetNumber: 20;
                TQ_UINT32 offsetCount: 12;
            } fields;
        } header;
        TQ_UINT32 offset;
    } data;
    TQ_UINT32 length = 0;

    while (length < bytes)
    {
        unsigned i;

        // Walk references numbered between:
        //
        //    offsetNumber..offsetNumber + offsetCount - 1
        //
        operands >> data.header.info;
        length += sizeof(data.header.info);
	kdDebug(s_area) << "length1: " << length << endl;
	kdDebug(s_area) << "m_pass: " << m_pass << endl;
	//kdDebug(s_area) << "PASS_GET_SLIDE_REFERENCES: " << PASS_GET_SLIDE_REFERENCES << endl;
	kdDebug(s_area) << "data.header.fields.offsetCount: " << data.header.fields.offsetCount << endl;

        for (i = 0; i < data.header.fields.offsetCount; i++)
        {
            unsigned reference = data.header.fields.offsetNumber + i;

            operands >> data.offset;
            length += sizeof(data.offset);
	    //kdDebug(s_area) << "length2: " << length << endl;
            switch (m_pass)
            {
            case PASS_GET_SLIDE_REFERENCES:

                // Create a record of this persistent reference.

                if (m_persistentReferences.end() == m_persistentReferences.find(reference))
                {
		    if(reference < 5)
		    {
                    	kdDebug(s_area) << "persistent reference: " << reference <<
                        		   ": " << data.offset << endl;
	            }
                    m_persistentReferences.insert(reference, data.offset);
                }
                else
                {
                    // This reference has already been seen! Since the parse proceeds
                    // backwards in time form the most recent edit, I assume this means
                    // that this is an older version of this slide...so just ignore it.
                   // kdDebug(s_area) << "superseded reference: " << reference <<
                   //     ": " << data.offset << endl;
                }
                break;
            case PASS_GET_SLIDE_CONTENTS:
                break;
            };
        }
 	kdDebug(s_area) << "LEAVING persistant block -- " << endl;
   }

}

void Powerpoint::opPPDrawing(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opPPDrawingGroup(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opSlide(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opSlideAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &operands)
{
    struct
    {
        TQ_UINT8 layout[12];  // Slide layout descriptor.
        TQ_INT32 masterId;   // Id of the master of the slide. Zero for a master slide.
        TQ_INT32 notesId;    // Id for the corresponding notes slide. Zero if slide has no notes.
        TQ_UINT16 flags;
    } data;

    Header tmp;
    tmp.type = 1015;
    tmp.length = sizeof(data.layout);
    invokeHandler(tmp, tmp.length, operands);
    operands >> data.masterId >> data.notesId >> data.flags;

    kdDebug(s_area) << "\nSlideAtom:" <<
                       "\n\tmasterId: " << data.masterId <<
		       "\n\tnotesId: " << data.notesId <<
		       "\n\tflags: " << data.flags << endl;

    //invokeHandler(tmp, tmp.length, operands);

}

void Powerpoint::opSlideListWithText(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opSlidePersistAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &operands)
{
    struct
    {
        TQ_UINT32 psrReference;   // Logical reference to the slide persist object.
        TQ_UINT32 flags;          // If bit 3 set then slide contains shapes other than placeholders.
        TQ_INT32 numberTexts;    // Number of placeholder texts stored with the persist object.
        TQ_INT32 slideId;        // Unique slide identifier, used for OLE link monikers for example.
        TQ_UINT32 reserved;
    } data;

    operands >> data.psrReference >> data.flags >> data.numberTexts >>
        data.slideId >> data.reserved;

     kdDebug(s_area) << "\nopSlidePersistAtom: " <<
    	               "\n\tpsrReference: " << data.psrReference <<
		       "\n\tflags: " << data.flags <<
		       "\n\tnumberTexts: " << data.numberTexts <<
		       "\n\tslideId: " << data.slideId <<
		       "\n\treserved: " << data.reserved << endl;

   switch (m_pass)
    {
    case PASS_GET_SLIDE_REFERENCES:
    	if(data.slideId > 0)//if not master slide.. is there another way to tell???
	{
		m_pptSlide = new PptSlide;
		m_pptSlide->setPsrReference(data.psrReference);
		m_slideList.append(m_pptSlide);

		kdDebug(s_area) << "XXXXXXXXXslide: " << data.psrReference <<
		" has texts: " << data.numberTexts << endl;
	}
        break;
    case PASS_GET_SLIDE_CONTENTS:
        break;
    };
}

void Powerpoint::opSlideViewInfo(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opSrKinsoku(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::opSSDocInfoAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opSSSlideLayoutAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &operands)
{

    PSR_SSlideLayoutAtom data;
    unsigned i;

    operands >> data.geom;
    for (i = 0; i < sizeof(data.placeholderId); i++)
    {
        operands >> data.placeholderId[i];
    }

    kdDebug(s_area) << "\nPSR_SSlideLayoutAtom:" <<
                       "\n\tgeom: " << data.geom <<
		       "\n\tplaceholderId[0]: " << data.placeholderId[0] <<
		       "\n\tplaceholderId[1]: " << data.placeholderId[1] <<
		       "\n\tplaceholderId[2]: " << data.placeholderId[2] <<
		       "\n\tplaceholderId[3]: " << data.placeholderId[3] <<
		       "\n\tplaceholderId[4]: " << data.placeholderId[4] <<
		       "\n\tplaceholderId[5]: " << data.placeholderId[5] <<
		       "\n\tplaceholderId[6]: " << data.placeholderId[6] <<
		       "\n\tplaceholderId[7]: " << data.placeholderId[7] << endl;

}
//this is where we set bold/italic/etc and paragraph styles
void Powerpoint::opStyleTextPropAtom(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{

	TQ_UINT16 totalLength = 0;
	TQ_UINT16 length = 0;
	TQ_UINT32 style1 = 0;
	TQ_UINT32 style2 = 0;
	TQ_UINT16 style3 = 0;
	TQ_UINT32 BOLD 		= 0x00010000;
	TQ_UINT32 ITALIC		= 0x00020000;
	TQ_UINT32 UNDERLINE 	= 0x00040000;

	//--get the paragraph style?
	operands >> length >> style1 >> style2;
	totalLength += 10;

	kdDebug(s_area) << "\nopStyleTextPropAtom1:" <<
			"\n\tlength: " << length <<
			"\n\tstyle1: " << style1 <<
			"\n\tstyle2: " << style2 << endl;
	//--

	//--get the char styles
	while(bytes > totalLength)
	{
		length = 0;
		style1 = 0;
		style2 = 0;
		style3 = 0;

		operands >> length >> style1;
		totalLength += 6;
		if(style1 == 0)
		{
			operands >> style3;
			totalLength += 2;
		}
		else
		{
			operands >> style2;
			totalLength += 4;
		}

		kdDebug(s_area) << "\nopStyleTextPropAtom2:" <<
				"\n\tlength: " << length <<
				"\n\tstyle1: " << style1 <<
				"\n\tstyle2: " << style2 <<
				"\n\tstyle3: " << style3 << endl;
		if(style1 & BOLD)
			kdDebug(s_area) << "BOLD here" << endl;
		if(style1 & ITALIC)
			kdDebug(s_area) << "ITALIC here" << endl;
		if(style1 & UNDERLINE)
			kdDebug(s_area) << "UNDERLINE here" << endl;
	}
	//--
}

void Powerpoint::opTextBytesAtom(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    TQString data;
    unsigned i;

    for (i = 0; i < bytes; i++)
    {
        TQ_UINT8 tmp;

        operands >> tmp;
        data += tmp;
    }
     kdDebug(s_area) << "\nopTextBytesAtom: " <<
    		       "\n\tdata: " << data << endl;

    //SlideText *text;
    switch (m_pass)
    {
    case PASS_GET_SLIDE_REFERENCES:
        //text = new SlideText;
        //text->type = m_textType;
        //text->data = data;
        //m_slide->text.append(text);
	if(m_pptSlide)
	{
		m_pptSlide->addText(data, m_textType);
		kdDebug(s_area) << "Text Added: " << data << " type: " << m_textType << endl;
	}
	else
	     	kdDebug(s_area) << "WEVE GOTS US AN ERROR!!!" << endl;

        break;
    case PASS_GET_SLIDE_CONTENTS:
        break;
    };
}

void Powerpoint::opTextCharsAtom(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    TQString data;
    unsigned i;

    for (i = 0; i < bytes / 2; i++)
    {
        TQ_UINT16 tmp;

        operands >> tmp;
        data += tmp;
    }

    //SlideText *text;
    switch (m_pass)
    {
    case PASS_GET_SLIDE_REFERENCES:
        //text = new SlideText;
        //text->type = m_textType;
        //text->data = data;
        //m_slide->text.append(text);
	if(m_pptSlide)
	{
		m_pptSlide->addText(data, m_textType);
		kdDebug(s_area) << "Text Added: " << data << " type: " << m_textType << endl;
	}
	else
	     	kdDebug(s_area) << "WEVE GOTS US AN ERROR!!!" << endl;

        break;
    case PASS_GET_SLIDE_CONTENTS:
        break;
    };
}

void Powerpoint::opTextHeaderAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &operands)
{
    struct
    {
        TQ_UINT32 txType;    // Type of text:
                            //
                            // 0 Title
                            // 1 Body
                            // 2 Notes
                            // 3 Not Used
                            // 4 Other (Text in a shape)
                            // 5 Center body (subtitle in title slide)
                            // 6 Center title (title in title slide)
                            // 7 Half body (body in two-column slide)
                            // 8 Quarter body (body in four-body slide)
     } data;

    operands >> data.txType;

    kdDebug(s_area) << "\nopTextHeaderAtom:" <<
    		       "\n\ttxType: " << data.txType << endl;

    switch (m_pass)
    {
    case PASS_GET_SLIDE_REFERENCES:
        m_textType = data.txType;
        break;
    case PASS_GET_SLIDE_CONTENTS:
        break;
    };
}

void Powerpoint::opTextSpecInfoAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opTxMasterStyleAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

void Powerpoint::opTxSIStyleAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &/*operands*/)
{
}

//
// This routine is where the parse actually gets going. It should be the first
// structure encoutered in the main OLE stream.
//
void Powerpoint::opUserEditAtom(
    Header & /* op */,
    TQ_UINT32 /*bytes*/,
    TQDataStream &operands)
{

    operands >> mUserEditAtom.lastSlideID  >> mUserEditAtom.version >> mUserEditAtom.offsetLastEdit >>
        mUserEditAtom.offsetPersistDirectory >> mUserEditAtom.documentRef >>
        mUserEditAtom.maxPersistWritten >> mUserEditAtom.lastViewType;

    if(mEditOffset == 0)mEditOffset = mUserEditAtom.offsetLastEdit;

    kdDebug(s_area) << "\nPSR_UserEditAtom:" <<
                       "\n\tlastSlideID: " << mUserEditAtom.lastSlideID <<
		       "\n\tversion: " << mUserEditAtom.version <<
		       "\n\toffsetLastEdit: " << mUserEditAtom.offsetLastEdit <<
		       "\n\toffsetPersistDirectory: " << mUserEditAtom.offsetPersistDirectory <<
		       "\n\tdocumentRef: " << mUserEditAtom.documentRef <<
		       "\n\tmaxPersistWritten: " << mUserEditAtom.maxPersistWritten <<
		       "\n\tlastViewType: " << mUserEditAtom.lastViewType << endl;

    if (!m_documentRefFound)
    {
        m_documentRef = mUserEditAtom.documentRef;
        m_documentRefFound = true;
    }
    switch (m_pass)
    {
    case PASS_GET_SLIDE_REFERENCES:

        // Gather the persistent references. That should fill the list of
        // references which we then use to look up our document.

        walkRecord(mUserEditAtom.offsetPersistDirectory);

        // Now recursively walk the main OLE stream parsing previous edits.

        if (mUserEditAtom.offsetLastEdit)
        {
            m_editDepth++;
            walkRecord(mUserEditAtom.offsetLastEdit);
            m_editDepth--;
        }
        break;
    case PASS_GET_SLIDE_CONTENTS:
        break;
    };
}

void Powerpoint::opVBAInfo(
    Header & /* op */,
    TQ_UINT32 bytes,
    TQDataStream &operands)
{
    walk(bytes, operands);
}

void Powerpoint::skip(TQ_UINT32 bytes, TQDataStream &operands)
{
    if ((int)bytes < 0)
    {
        kdError(s_area) << "skip: " << (int)bytes << endl;
        return;
    }
    if (bytes)
    {
        TQ_UINT32 i;
        TQ_UINT8 discard;

        kdDebug(s_area) << "skip: " << bytes << endl;
        for (i = 0; i < bytes; i++)
        {
            operands >> discard;
        }
    }
}

//
// Handle a container record.
//
void Powerpoint::walk(TQ_UINT32 bytes, TQDataStream &operands)
{
    Header op;
    TQ_UINT32 length = 0;

    // Stop parsing when there are no more records. Note that we stop as soon
    // as we cannot get a complete header.
    while (length + 8 <= bytes)
    {
        operands >> op.opcode.info >> op.type >> op.length;

        // If we get some duff data, protect ourselves.
        if (length + op.length + 8 > bytes)
        {
            op.length = bytes - length - 8;
        }
        length += op.length + 8;

        // Package the arguments...

	invokeHandler(op, op.length, operands);
    }

    // Eat unexpected data that the caller may expect us to consume.
    skip(bytes - length, operands);
}

void Powerpoint::walk(TQ_UINT32 mainStreamOffset)
{
    TQ_UINT32 length = m_mainStream.length - mainStreamOffset;
    TQByteArray a;

    a.setRawData((const char *)m_mainStream.data + mainStreamOffset, length);
    TQDataStream stream(a, IO_ReadOnly);
    stream.setByteOrder(TQDataStream::LittleEndian);
    walk(length, stream);
    a.resetRawData((const char *)m_mainStream.data + mainStreamOffset, length);
}
void Powerpoint::walkDocument()
{
    TQByteArray a;
    TQ_UINT32 mainStreamOffset = 0;
    TQ_UINT32 bytes = m_mainStream.length - mainStreamOffset;

    a.setRawData((const char *)m_mainStream.data + mainStreamOffset, bytes);
    TQDataStream stream(a, IO_ReadOnly);
    stream.setByteOrder(TQDataStream::LittleEndian);
    //--get tho the slide list
    Header op;
    TQ_UINT32 length = 0;

    // Stop parsing when there are no more records. Note that we stop as soon
    // as we cannot get a complete header.
    while (length + 8 <= bytes && op.type != 1000)//document
    {
        stream >> op.opcode.info >> op.type >> op.length;

        // If we get some duff data, protect ourselves.
        if (length + op.length + 8 > bytes)
        {
            op.length = bytes - length - 8;
        }
        length += op.length + 8;
    }

    //--
    invokeHandler(op, op.length, stream);
    a.resetRawData((const char *)m_mainStream.data + mainStreamOffset, bytes);

}

void Powerpoint::walkRecord(TQ_UINT32 bytes, const unsigned char *operands)
{
    // First read what should be the next header using one stream.

    kdError(s_area) << "WalkRecord - bytes: " << bytes << endl;

    TQ_UINT32 length = sizeof(Header);
    TQByteArray a;
    Header op;

    a.setRawData((const char *)operands, bytes);
    TQDataStream stream1(a, IO_ReadOnly);
    stream1.setByteOrder(TQDataStream::LittleEndian);
    stream1 >> op.opcode.info >> op.type >> op.length;
    a.resetRawData((const char *)operands, bytes);

    // Armed with the length, parse in the usual way using a second stream.

    length += op.length;
    a.setRawData((const char *)operands, length);
    TQDataStream stream2(a, IO_ReadOnly);
    stream2.setByteOrder(TQDataStream::LittleEndian);
    walk(length, stream2);
    a.resetRawData((const char *)operands, length);
}

void Powerpoint::walkRecord(TQ_UINT32 mainStreamOffset)
{
    walkRecord(sizeof(Header), m_mainStream.data + mainStreamOffset);
}

void Powerpoint::walkReference(TQ_UINT32 reference)
{
    if (m_persistentReferences.end() == m_persistentReferences.find(reference))
    {
        kdError(s_area) << "cannot find reference: " << reference << endl;
    }
    else
    {
        unsigned offset = m_persistentReferences[reference];
        kdDebug(s_area) << "found reference: " << reference <<
            " offset: " << offset << endl;
        walkRecord(offset);
	kdDebug(s_area) << "****************************" << endl;

    }
}