/*
   This file is part of the KDE project
   Copyright (C) 2001, 2002, 2004 Nicolas GOUTTE <goutte@kde.org>
   Copyright (c) 2001 IABG mbH. All rights reserved.
                      Contact: Wolf-Michael Bolle <Bolle@IABG.de>

   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.
*/

/*
   Part of this code comes from the old file:
    /home/kde/koffice/filters/kword/ascii/asciiexport.cpp

   The old file was copyrighted by
    Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
    Copyright (c) 2000 ID-PRO Deutschland GmbH. All rights reserved.
                       Contact: Wolf-Michael Bolle <Wolf-Michael.Bolle@GMX.de>

   The old file was licensed under the terms of the GNU Library General Public
   License version 2.
*/

#include <tqfile.h>
#include <tqdom.h>

#include <kdebug.h>
#include <tdelocale.h>
#include <tdemessagebox.h>

#include <KoGlobal.h>
#include <KoStore.h>

#include "KWEFStructures.h"
#include "TagProcessing.h"
#include "ProcessDocument.h"
#include "KWEFBaseWorker.h"
#include "KWEFKWordLeader.h"

KWEFKWordLeader::KWEFKWordLeader(void)
    : m_syntaxVersion(-1), m_oldSyntax(false), m_worker(NULL), m_chain(NULL), m_hType(0), m_fType(0)
{
}

KWEFKWordLeader::KWEFKWordLeader(KWEFBaseWorker* newWorker)
    : m_syntaxVersion(-1), m_oldSyntax(false), m_worker(newWorker), m_chain(NULL)
{
    if (newWorker) newWorker->registerKWordLeader(this);
}

KWEFKWordLeader::~KWEFKWordLeader(void)
{
}

static FrameAnchor *findAnchor ( const KoPictureKey& key,
                                 TQValueList<ParaData>& paraList )
{
    kdDebug(30508) << "findAnchor " << key.toString() << endl;
    TQValueList<ParaData>::Iterator paraIt;

    for ( paraIt = paraList.begin (); paraIt != paraList.end (); ++paraIt )
    {
        ValueListFormatData::Iterator formattingIt;

        for ( formattingIt = (*paraIt).formattingList.begin ();
              formattingIt != (*paraIt).formattingList.end ();
              formattingIt++ )
        {
            if ( (*formattingIt).id              == 6    &&
                 (*formattingIt).frameAnchor.key == key )
            {
                kdDebug(30508) << "Found anchor " << (*formattingIt).frameAnchor.key.toString() << endl;
                return &(*formattingIt).frameAnchor;
            }
        }
    }

    kdWarning(30508) << "findAnchor returning NULL!" << endl;
    return NULL;
}

static void ProcessHardBrkTag ( TQDomNode myNode, void* tagData, KWEFKWordLeader* )
{
    // <HARDBRK>
    bool* flag = (bool*) tagData;
    TQValueList<AttrProcessing> attrProcessingList;
    attrProcessingList << AttrProcessing ( "frame", *flag );
    ProcessAttributes (myNode, attrProcessingList);
    if (*flag)
        kdDebug(30508) << "<HARDBRK frame=\"1\"> found" << endl;
}

static void InsertBookmarkFormatData (const int pos, const TQString& name, const bool start,
    ValueListFormatData &paraFormatDataList)
{
    ValueListFormatData::Iterator  paraFormatDataIt;

    FormatData book( start ? 1001 : 1002 , pos, 0 );
    book.variable.m_text = name;

    for (paraFormatDataIt = paraFormatDataList.begin ();
        paraFormatDataIt != paraFormatDataList.end ();
        paraFormatDataIt++)
    {
        if ( pos <= (*paraFormatDataIt).pos )
        {
            paraFormatDataList.insert ( paraFormatDataIt, book );
            return;

        }
        if ( ( pos > (*paraFormatDataIt).pos ) && ( pos < (*paraFormatDataIt).pos + (*paraFormatDataIt).len ) )
        {
            // Somewhere in the middle, we have to split the FormatData
            FormatData split ( *paraFormatDataIt );
            //const int oldlen = (*paraFormatDataIt).len;
            split.len = pos - (*paraFormatDataIt).pos;
            (*paraFormatDataIt).len -= split.len;
            (*paraFormatDataIt).pos = pos;
            paraFormatDataList.insert ( paraFormatDataIt, split );
            paraFormatDataList.insert ( paraFormatDataIt, book );
            return;
        }
    }

    // Still here? So we need to put the bookmark here:
    paraFormatDataList.append ( book );
}


void KWEFKWordLeader::createBookmarkFormatData( ParaData& paraData )
{
    const int paraCount = m_paraCountMap[ m_currentFramesetName ];

    TQValueList<Bookmark>::ConstIterator it;
    for (it = m_bookmarkList.begin(); it != m_bookmarkList.end(); ++it )
    {
        if ( (*(it)).m_frameset != m_currentFramesetName )
        {
            continue;
        }
        // As we always insert before, make first endings, then startings (problem is zero-length bookmark)
        if ( (*(it)).m_endparag == paraCount )
        {
            kdDebug(30508) << "Paragraph: " << paraCount << " end: " << (*(it)).m_name << endl;
            InsertBookmarkFormatData( (*(it)).m_cursorIndexEnd, (*(it)).m_name, false, paraData.formattingList);

        }
        if ( (*(it)).m_startparag == paraCount )
        {
            kdDebug(30508) << "Paragraph: " << paraCount << " begin: " << (*(it)).m_name << endl;
            InsertBookmarkFormatData( (*(it)).m_cursorIndexStart, (*(it)).m_name, true, paraData.formattingList);
        }
    }
}

static void ProcessParagraphTag ( TQDomNode         myNode,
                                  void            *tagData,
                                  KWEFKWordLeader *leader )
{
#if 0
    kdDebug (30508) << "ProcessParagraphTag () - Begin" << endl;
#endif

    TQValueList<ParaData> *paraList = (TQValueList<ParaData> *) tagData;

    AllowNoAttributes (myNode);

    // We need to adjust the paragraph number (0 if first)
    TQMap<TQString,int>::Iterator it = leader->m_paraCountMap.find( leader->m_currentFramesetName );
    if ( it == leader->m_paraCountMap.end() )
        leader->m_paraCountMap.insert( leader->m_currentFramesetName, 0 );
    else
        ++(*it);
    
    ParaData paraData;

    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList << TagProcessing ( "TEXT",    ProcessTextTag,     &paraData.text           )
                      << TagProcessing ( "FORMATS", ProcessFormatsTag,  &paraData.formattingList )
                      << TagProcessing ( "LAYOUT",  ProcessLayoutTag,   &paraData.layout         );
    
    if ( leader->m_oldSyntax )
    {
        tagProcessingList.append( TagProcessing( "HARDBRK", ProcessHardBrkTag, &paraData.layout.pageBreakBefore ) );
    }
    ProcessSubtags (myNode, tagProcessingList, leader);

    leader->createBookmarkFormatData( paraData );
    CreateMissingFormatData (paraData.text, paraData.formattingList);

    // TODO/FIXME: why !paraData.text.isEmpty()
    if ( paraData.formattingList.isEmpty () && !paraData.text.isEmpty () )
    {
        if ( paraData.layout.formatData.id == 1 )
        {
            paraData.formattingList << paraData.layout.formatData;
        }
        else
        {
            kdWarning (30508) << "No useful FORMAT tag found for text in PARAGRAPH" << endl;
        }
    }


    *paraList << paraData;

#if 0
    kdDebug (30508) << "ProcessParagraphTag () - End " << paraText << endl;
#endif
}


static void ProcessFrameTag ( TQDomNode myNode, void *tagData,
    KWEFKWordLeader *leader )
{
    FrameAnchor* frameAnchor= (FrameAnchor*) tagData;

    int lRed=0, lBlue=0, lGreen=0;
    int rRed=0, rBlue=0, rGreen=0;
    int tRed=0, tBlue=0, tGreen=0;
    int bRed=0, bBlue=0, bGreen=0;
    int bkRed=255, bkBlue=255, bkGreen=255;

    frameAnchor->frame.lWidth=0.0;
    frameAnchor->frame.rWidth=0.0;
    frameAnchor->frame.tWidth=0.0;
    frameAnchor->frame.bWidth=0.0;

    TQValueList<AttrProcessing> attrProcessingList;
    attrProcessingList
        << AttrProcessing ( "right",        frameAnchor->frame.right  )
        << AttrProcessing ( "left",         frameAnchor->frame.left   )
        << AttrProcessing ( "top",          frameAnchor->frame.top    )
        << AttrProcessing ( "bottom",       frameAnchor->frame.bottom )

        << AttrProcessing ( "min-height",   frameAnchor->frame.minHeight )

        << AttrProcessing ( "runaround",      frameAnchor->frame.runaround         )
        << AttrProcessing ( "runaroundSide",  frameAnchor->frame.runaroundSide )
        << AttrProcessing ( "runaroundGap",   frameAnchor->frame.runaroundGap   )

        << AttrProcessing ( "autoCreateNewFrame",  frameAnchor->frame.autoCreateNewFrame )
        << AttrProcessing ( "newFrameBehavior",    frameAnchor->frame.newFrameBehavior   )
        << AttrProcessing ( "newFrameBehaviour", frameAnchor->frame.newFrameBehavior ) // Depreciated name

        << AttrProcessing ( "copy",       frameAnchor->frame.copy      )
        << AttrProcessing ( "sheetSide",  frameAnchor->frame.sheetSide )

        << AttrProcessing ( "lWidth",   frameAnchor->frame.lWidth )
        << AttrProcessing ( "rWidth",   frameAnchor->frame.rWidth )
        << AttrProcessing ( "tWidth",   frameAnchor->frame.tWidth )
        << AttrProcessing ( "bWidth",   frameAnchor->frame.bWidth )

        << AttrProcessing ( "lRed",     lRed   )
        << AttrProcessing ( "lGreen",   lGreen )
        << AttrProcessing ( "lBlue",    lBlue  )

        << AttrProcessing ( "rRed",     rRed   )
        << AttrProcessing ( "rGreen",   rGreen )
        << AttrProcessing ( "rBlue",    rBlue  )

        << AttrProcessing ( "tRed",     tRed   )
        << AttrProcessing ( "tGreen",   tGreen )
        << AttrProcessing ( "tBlue",    tBlue  )

        << AttrProcessing ( "bRed",     bRed   )
        << AttrProcessing ( "bGreen",   bGreen )
        << AttrProcessing ( "bBlue",    bBlue  )

        << AttrProcessing ( "lStyle",    frameAnchor->frame.lStyle )
        << AttrProcessing ( "rStyle",    frameAnchor->frame.rStyle )
        << AttrProcessing ( "tStyle",    frameAnchor->frame.tStyle )
        << AttrProcessing ( "bStyle",    frameAnchor->frame.bStyle )

        << AttrProcessing ( "bkRed",     bkRed   )
        << AttrProcessing ( "bkGreen",   bkGreen )
        << AttrProcessing ( "bkBlue",    bkBlue  )

        << AttrProcessing ( "bkStyle",    frameAnchor->frame.bkStyle )

        << AttrProcessing ( "bleftpt",     frameAnchor->frame.bleftpt   )
        << AttrProcessing ( "brightpt",    frameAnchor->frame.brightpt  )
        << AttrProcessing ( "btoppt",      frameAnchor->frame.btoppt    )
        << AttrProcessing ( "bbottompt",   frameAnchor->frame.bbottompt )
        ;

    if ( leader->m_oldSyntax )
    {
        attrProcessingList
            << AttrProcessing ( "bleftmm" )
            << AttrProcessing ( "bleftinch" )
            << AttrProcessing ( "brightmm" )
            << AttrProcessing ( "brightinch" )
            << AttrProcessing ( "btopmm" )
            << AttrProcessing ( "btopinch" )
            << AttrProcessing ( "bbottommm" )
            << AttrProcessing ( "bbottominch" )
            ;
    }
    
    ProcessAttributes (myNode, attrProcessingList);

    frameAnchor->frame.lColor.setRgb( lRed, lGreen, lBlue );
    frameAnchor->frame.rColor.setRgb( rRed, rGreen, rBlue );
    frameAnchor->frame.tColor.setRgb( tRed, tGreen, tBlue );
    frameAnchor->frame.bColor.setRgb( bRed, bGreen, bBlue );
    frameAnchor->frame.bkColor.setRgb( bkRed, bkGreen, bkBlue );

    AllowNoSubtags (myNode, leader);
}

static void ProcessPictureAnchor( TQDomNode myNode, KWEFKWordLeader *leader, FrameAnchor* frameAnchor, const int frameType )
{
    frameAnchor->type = frameType;
 
    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList
        << TagProcessing ( "FRAME",   ProcessFrameTag, frameAnchor )
        << TagProcessing ( "PICTURE", ProcessImageTag, &frameAnchor->picture.key )
        << TagProcessing ( "IMAGE",   ProcessImageTag, &frameAnchor->picture.key )
        << TagProcessing ( "CLIPART", ProcessImageTag, &frameAnchor->picture.key )
        ;
    ProcessSubtags (myNode, tagProcessingList, leader);

    kdDebug (30508) << "FRAMESET PICTURE KEY " << frameAnchor->picture.key.toString() << endl;

    frameAnchor->key = frameAnchor->picture.key;
}

static void ProcessTableAnchor( TQDomNode myNode, KWEFKWordLeader *leader, FrameAnchor* frameAnchor,
    const int col, const int row, const int cols, const int rows )
{
    frameAnchor->type = 6; // Table

    TQValueList<ParaData> cellParaList;
    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList << TagProcessing ( "FRAME",     ProcessFrameTag,     frameAnchor   )
                        << TagProcessing ( "PARAGRAPH", ProcessParagraphTag, &cellParaList );
    ProcessSubtags (myNode, tagProcessingList, leader);

    frameAnchor->table.addCell (col, row, cols, rows, cellParaList, frameAnchor->frame);
}

static void ProcessFramesetTag ( TQDomNode        myNode,
                                void            *tagData,
                                KWEFKWordLeader *leader )
{
#if 0
    kdDebug (30508) << "ProcessFramesetTag () - Begin" << endl;
#endif

    TQValueList<ParaData> *paraList = (TQValueList<ParaData> *) tagData;

    int     frameType = -1;
    int     frameInfo = -1;
    int     col       = -1;
    int     row       = -1;
    int     cols      = -1;
    int     rows      = -1;
    TQString grpMgr;

    const TQString oldName ( leader->m_currentFramesetName );
    
    TQValueList<AttrProcessing> attrProcessingList;
    attrProcessingList << AttrProcessing ( "name",        leader->m_currentFramesetName      )
                       << AttrProcessing ( "frameType",   frameType )
                       << AttrProcessing ( "frameInfo",   frameInfo )
                       << AttrProcessing ( "removable" )
                       << AttrProcessing ( "visible" )
                       << AttrProcessing ( "grpMgr",      grpMgr    )
                       << AttrProcessing ( "row",         row       )
                       << AttrProcessing ( "col",         col       )
                       << AttrProcessing ( "rows",        rows      )
                       << AttrProcessing ( "cols",        cols      )
                       << AttrProcessing ( "protectSize" )
                        ;
    ProcessAttributes (myNode, attrProcessingList);

    switch ( frameType )
    {
    case 1:
            if ( grpMgr.isEmpty () )
            {
                // As we do not support anything else than normal text, process only normal text.
                // TODO: Treat the other types of frames (frameType)
                if (frameInfo==0)
                {
                    // Normal Text
                    kdDebug(30508) << "Processing Frameset: " << leader->m_currentFramesetName << endl;
                    TQValueList<TagProcessing> tagProcessingList;
                    tagProcessingList.append(TagProcessing ( "FRAME" ));
                    tagProcessingList.append(TagProcessing ( "PARAGRAPH", ProcessParagraphTag,  paraList ));
                    ProcessSubtags (myNode, tagProcessingList, leader);
                }
                else if (frameInfo==1)
                {
                    // header for first page
                    HeaderData header;
                    header.page = HeaderData::PAGE_FIRST;
                    TQValueList<TagProcessing> tagProcessingList;
                    tagProcessingList.append(TagProcessing ( "FRAME" ));
                    tagProcessingList.append(TagProcessing ( "PARAGRAPH", ProcessParagraphTag,  &header.para ));

                    ProcessSubtags (myNode, tagProcessingList, leader);
                    leader->doHeader( header );
                }
                else if (frameInfo==2)
                {
                    // header for even page
                    HeaderData header;
                    header.page = HeaderData::PAGE_EVEN;
                    TQValueList<TagProcessing> tagProcessingList;
                    tagProcessingList.append(TagProcessing ( "FRAME" ));
                    tagProcessingList.append(TagProcessing ( "PARAGRAPH", ProcessParagraphTag,  &header.para ));
                    ProcessSubtags (myNode, tagProcessingList, leader);
                    leader->doHeader( header );
                }
                else if (frameInfo==3)
                {
                    // header for odd page (or all page, if hType=0)
                    HeaderData header;
                    header.page = (leader->headerType() != 0 ) ? HeaderData::PAGE_ODD : HeaderData::PAGE_ALL;
                    TQValueList<TagProcessing> tagProcessingList;
                    tagProcessingList.append(TagProcessing ( "FRAME" ));
                    tagProcessingList.append(TagProcessing ( "PARAGRAPH", ProcessParagraphTag,  &header.para ));
                    ProcessSubtags (myNode, tagProcessingList, leader);
                    leader->doHeader( header );
                }
                else if (frameInfo==4)
                {
                    // footer for first page
                    FooterData footer;
                    footer.page = FooterData::PAGE_FIRST;
                    TQValueList<TagProcessing> tagProcessingList;
                    tagProcessingList.append(TagProcessing ( "FRAME" ));
                    tagProcessingList.append(TagProcessing ( "PARAGRAPH", ProcessParagraphTag,  &footer.para ));
                    ProcessSubtags (myNode, tagProcessingList, leader);
                    leader->doFooter( footer );
                }
                else if (frameInfo==5)
                {
                    // footer for even page
                    FooterData footer;
                    footer.page = FooterData::PAGE_EVEN;
                    TQValueList<TagProcessing> tagProcessingList;
                    tagProcessingList.append(TagProcessing ( "FRAME" ));
                    tagProcessingList.append(TagProcessing ( "PARAGRAPH", ProcessParagraphTag,  &footer.para ));
                    ProcessSubtags (myNode, tagProcessingList, leader);
                    leader->doFooter( footer );
                }
                else if (frameInfo==6)
                {
                    // footer for odd page (or all page, if fType=0)
                    FooterData footer;
                    footer.page = (leader->footerType() != 0) ? FooterData::PAGE_ODD : FooterData::PAGE_ALL;
                    TQValueList<TagProcessing> tagProcessingList;
                    tagProcessingList.append(TagProcessing ( "FRAME" ));
                    tagProcessingList.append(TagProcessing ( "PARAGRAPH", ProcessParagraphTag,  &footer.para ));
                    ProcessSubtags (myNode, tagProcessingList, leader);
                    leader->doFooter( footer );
                }
            }
            else
            {
                if ( col != -1 && row != -1 )
                {
                    if ( cols > 0 && rows > 0 )
                    {
#if 0
                        kdDebug (30508) << "DEBUG - FRAMESET: table " << name << " col, row = "
                                        << col << ", " << row << ", Mgr = "<< grpMgr << endl;
#endif
                        FrameAnchor *frameAnchor = findAnchor (grpMgr, *paraList);
                        if ( frameAnchor )
                        {
                            ProcessTableAnchor( myNode, leader, frameAnchor, col, row, cols, rows );
                        }
                        else
                        {
                            bool found = false;
                            KoPictureKey key( grpMgr );
                            TQValueList<FrameAnchor>::Iterator it;
                            for ( it = leader->m_nonInlinedTableAnchors.begin(); it !=  leader->m_nonInlinedTableAnchors.end(); ++it )
                            {
                                if ( (*it).key == key )
                                {
                                    kdDebug(30508) << "Found pseudo-anchor for table: " << (*it).key.toString() << endl;
                                    found = true;
                                    break;
                                }
                            }
                            
                            if ( found )
                            {
                                ProcessTableAnchor( myNode, leader, &(*it), col, row, cols, rows );
                            }
                            else
                            {
                                kdWarning(30508) << "Table anchor not found: " << grpMgr << endl;
                                FrameAnchor anchor;
                                ProcessTableAnchor( myNode, leader, &anchor, col, row, cols, rows );
                                anchor.key = key; // Needed, so that the pseudo-anchor can be found again
                                leader->m_nonInlinedTableAnchors << anchor;
                                leader->m_unanchoredFramesets.append( grpMgr );
                            }
                        }
                    }
                    else
                    {
                        kdWarning (30508) << "Unexpected value for one of, or all FRAMESET attribute cols, rows: "
                                        << cols << ", " << rows << "!" << endl;
                        AllowNoSubtags (myNode, leader);
                    }
                }
                else
                {
                    kdWarning (30508) << "Unset value for one of, or all FRAMESET attributes col, row: "
                                    << col << ", " << row << "!" << endl;
                    AllowNoSubtags (myNode, leader);
                    leader->m_unanchoredFramesets.append( leader->m_currentFramesetName );
                }
            }
            break;

    case 2: // PICTURE
    case 5: // CLIPART: deprecated (up to KOffice 1.2 Beta 2)
        {
#if 0
            kdDebug (30508) << "DEBUG: FRAMESET name of picture is " << name << endl;
#endif

            FrameAnchor *frameAnchor = findAnchor ( leader->m_currentFramesetName, *paraList );

            if ( frameAnchor )
            {
                ProcessPictureAnchor( myNode, leader, frameAnchor, frameType );
            }
            else
            {
                // ### TODO: non-inlined picture?
                // No anchor found, so the picture is not inlined
                kdDebug (30508) << "ProcessFramesetTag: Couldn't find anchor " << leader->m_currentFramesetName << endl;
                FrameAnchor anchor;
                ProcessPictureAnchor( myNode, leader, &anchor, frameType );
                leader->m_nonInlinedPictureAnchors << anchor;
                leader->m_unanchoredFramesets.append( leader->m_currentFramesetName ); // DEBUG
            }

            break;
        }

    case 4: // KFormula
        {
            kdWarning(30508) << "KFormula frameset not supported yet!" << endl; // ### TODO
            break;
        }
    default:
            kdWarning (30508) << "Unexpected frametype " << frameType << " (in ProcessFramesetTag)" << endl;
    }

    leader->m_currentFramesetName = oldName;
    
#if 0
    kdDebug (30508) << "ProcessFramesetTag () - End" << endl;
#endif
}


static void ProcessFramesetsTag ( TQDomNode        myNode,
                                  void            *tagData,
                                  KWEFKWordLeader *leader )
{
    AllowNoAttributes (myNode);
    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList << TagProcessing ( "FRAMESET", ProcessFramesetTag, tagData );
    ProcessSubtags (myNode, tagProcessingList, leader);
}


static void ProcessStyleTag (TQDomNode myNode, void *, KWEFKWordLeader *leader )
{
    LayoutData layout;

    ProcessLayoutTag (myNode, &layout, leader);

    leader->doFullDefineStyle (layout);
}


static void ProcessStylesPluralTag (TQDomNode myNode, void *, KWEFKWordLeader *leader )
{
    AllowNoAttributes (myNode);

    leader->doOpenStyles ();

    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList << TagProcessing ( "STYLE", ProcessStyleTag, leader );
    ProcessSubtags (myNode, tagProcessingList, leader);

    leader->doCloseStyles ();
}


static void ProcessPaperBordersTag (TQDomNode myNode, void*, KWEFKWordLeader* leader)
{

    double left   = 0.0;
    double right  = 0.0;
    double top    = 0.0;
    double bottom = 0.0;

    TQValueList<AttrProcessing> attrProcessingList;
    if ( leader->m_oldSyntax )
    {
        attrProcessingList
            << AttrProcessing ( "ptLeft",   left )
            << AttrProcessing ( "ptRight",  right )
            << AttrProcessing ( "ptTop",    top )
            << AttrProcessing ( "ptBottom", bottom )
            << AttrProcessing ( "mmLeft" )
            << AttrProcessing ( "mmRight" )
            << AttrProcessing ( "mmTop" )
            << AttrProcessing ( "mmBottom" )
            << AttrProcessing ( "inchLeft" )
            << AttrProcessing ( "inchRight" )
            << AttrProcessing ( "inchTop" )
            << AttrProcessing ( "inchBottom" )
            ;
    }
    else
    {
        attrProcessingList
            << AttrProcessing ( "left",   left )
            << AttrProcessing ( "right",  right )
            << AttrProcessing ( "top",    top )
            << AttrProcessing ( "bottom", bottom )
            ;
    }
    ProcessAttributes (myNode, attrProcessingList);

    leader->doFullPaperBorders(top, left, bottom, right);

    AllowNoSubtags (myNode, leader);
}

static void ProcessPaperTag (TQDomNode myNode, void *, KWEFKWordLeader *leader)
{

    int format      = -1;
    int orientation = -1;
    double width    = -1.0;
    double height   = -1.0;
    int hType       = -1;
    int fType       = -1;
    int columns = 1;
    double columnspacing = 36.0; // Half-inch
    int numPages = -1;

    TQValueList<AttrProcessing> attrProcessingList;
    attrProcessingList << AttrProcessing ( "format",              format      )
                       << AttrProcessing ( "width",               width       )
                       << AttrProcessing ( "height",              height      )
                       << AttrProcessing ( "orientation",         orientation )
                       << AttrProcessing ( "columns",             columns )
                       << AttrProcessing ( "columnspacing",       columnspacing )
                       << AttrProcessing ( "pages",               numPages )
                       << AttrProcessing ( "hType",               hType        )
                       << AttrProcessing ( "fType",               fType        )
                       << AttrProcessing ( "spHeadBody" )
                       << AttrProcessing ( "spFootBody" )
                       << AttrProcessing ( "spFootNoteBody" )
                       << AttrProcessing ( "slFootNotePosition" )
                       << AttrProcessing ( "slFootNoteLength" )
                       << AttrProcessing ( "slFootNoteWidth" )
                       << AttrProcessing ( "slFootNoteType" );

    if ( leader->m_oldSyntax )
    {
        // ### TODO: in syntax 1 hType and fType have other values!
        attrProcessingList
            << AttrProcessing ( "ptWidth", width )
            << AttrProcessing ( "ptHeight", height )
            << AttrProcessing ( "ptColumnspc", columnspacing )
            << AttrProcessing ( "mmWidth" )
            << AttrProcessing ( "mmHeight" )
            << AttrProcessing ( "mmColumnspc" )
            << AttrProcessing ( "inchWidth" )
            << AttrProcessing ( "inchHeight" )
            << AttrProcessing ( "inchColumnspc" )
            ;
    }

    ProcessAttributes (myNode, attrProcessingList);

    leader->setHeaderType( hType );
    leader->setFooterType( fType );

    leader->doPageInfo ( hType, fType );
    leader->doFullPaperFormat (format, width, height, orientation);
    leader->doFullPaperFormatOther( columns, columnspacing, numPages );

    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList
        << TagProcessing ( "PAPERBORDERS", ProcessPaperBordersTag, NULL )
        ;

    ProcessSubtags (myNode, tagProcessingList, leader);
}

static void ProcessVariableSettingsTag (TQDomNode myNode, void *, KWEFKWordLeader *leader)
{
    VariableSettingsData vs;
    TQString print, creation, modification; // Dates (in ISO 8601 format)
    int creationYear = -1;
    int creationMonth = -1;
    int creationDay = -1;
    int modificationYear = -1;
    int modificationMonth = -1;
    int modificationDay = -1;

    TQValueList<AttrProcessing> attrProcessingList;
    attrProcessingList << AttrProcessing ( "startingPageNumber", vs.startingPageNumber )
                       << AttrProcessing ( "displaylink", vs.displaylink )
                       << AttrProcessing ( "underlinelink", vs.underlinelink )
                       << AttrProcessing ( "displaycomment", vs.displaycomment )
                       << AttrProcessing ( "displayfieldcode", vs.displayfieldcode )
        ;


    // The following 3 attributes are from syntax 3 but at least the RTF import filter generate them with syntax 2.
    attrProcessingList
        << AttrProcessing ( "lastPrintingDate", print )
        << AttrProcessing ( "creationDate", creation )
        << AttrProcessing ( "modificationDate", modification );
    ;

    // Some files have the creation and modification date not in one attribute but in an attribute for each the year, the month, the day
    // ( e.g. syntax 2 file kofficetests/documents/export/kword/text/all.kwd )
    attrProcessingList
        << AttrProcessing( "modifyFileYear", modificationYear )
        << AttrProcessing( "modifyFileMonth", modificationMonth )
        << AttrProcessing( "modifyFileDay", modificationDay )
        << AttrProcessing( "createFileYear", creationYear )
        << AttrProcessing( "createFileMonth", creationMonth )
        << AttrProcessing( "createFileDay", creationDay )
        ;

    ProcessAttributes (myNode, attrProcessingList);

    if ( creation.isEmpty() )
    {
        if ( ( creationYear >= 1970 ) && TQDate::isValid( creationYear, creationMonth, creationDay ) )
        {
            vs.creationTime = TQDateTime( TQDate( creationYear, creationMonth, creationDay ) );
        }
    }
    else
        vs.creationTime=TQDateTime::fromString(creation, Qt::ISODate);
    //kdDebug(30508) << "Creation time: " << vs.creationTime.toString( Qt::ISODate ) << endl;

    if ( modification.isEmpty() )
    {
        if ( ( modificationYear >= 1970 ) && TQDate::isValid( modificationYear, modificationMonth, modificationDay ) )
        {
            vs.modificationTime = TQDateTime( TQDate( modificationYear, modificationMonth, modificationDay ) );
        }
    }
    else
        vs.modificationTime=TQDateTime::fromString(modification, Qt::ISODate);
    //kdDebug(30508) << "Modification time: " << vs.modificationTime.toString( Qt::ISODate ) << endl;

    if (!print.isEmpty())
        vs.printTime=TQDateTime::fromString(print, Qt::ISODate);
    //kdDebug(30508) << "Print time: " << vs.printTime.toString( Qt::ISODate ) << endl;

    leader->doVariableSettings (vs);
}

static void ProcessSpellCheckIgnoreWordTag (TQDomNode myNode, void *, KWEFKWordLeader *leader )
{
    TQString ignoreword;

    TQValueList<AttrProcessing> attrProcessingList;
    attrProcessingList
        << AttrProcessing ( "word", ignoreword )
        ;
    ProcessAttributes (myNode, attrProcessingList);

    leader->doFullSpellCheckIgnoreWord (ignoreword);

    AllowNoSubtags (myNode, leader);
}


static void ProcessSpellCheckIgnoreListTag (TQDomNode myNode, void *, KWEFKWordLeader *leader )
{
    AllowNoAttributes (myNode);

    leader->doOpenSpellCheckIgnoreList ();

    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList << TagProcessing ( "SPELLCHECKIGNOREWORD", ProcessSpellCheckIgnoreWordTag, leader );
    ProcessSubtags (myNode, tagProcessingList, leader);

    leader->doCloseSpellCheckIgnoreList ();
}


static void ProcessPixmapsKeyTag ( TQDomNode         myNode,
                                   void            *tagData,
                                   KWEFKWordLeader *leader )
{
    TQValueList<ParaData> *paraList = (TQValueList<ParaData> *) tagData;

    KoPictureKey key;

    // Let KoPictureKey do most of the loading
    key.loadAttributes(myNode.toElement());
    const TQString name(myNode.toElement().attribute("name"));

    kdDebug(30508) << "search anchors: " << key.toString() << endl;
    bool found = false;

    // NOTE: we must always search in both inlined and non-inlined pictures. A picture can be used in both ways and a few times in each!
    
    // Process inlined pictures
    TQValueList<ParaData>::Iterator paraIt;

    for ( paraIt = paraList->begin(); paraIt != paraList->end(); ++paraIt )
    {
        ValueListFormatData::Iterator formattingIt;
        for ( formattingIt = (*paraIt).formattingList.begin();
              formattingIt != (*paraIt).formattingList.end();
              formattingIt++ )
        {
            if ( ( ( (*formattingIt).id == 6 ) || ( (*formattingIt).id == 2 ) )
                 && (*formattingIt).frameAnchor.key == key )
            {
                kdDebug(30508) << "Found anchor for inlined picture: " << (*formattingIt).frameAnchor.key.toString() << endl;
                (*formattingIt).frameAnchor.picture.koStoreName = name;
                found = true;
            }
        }
    }
    // Process non-inline pictures
    TQValueList<FrameAnchor>::Iterator it;
    for ( it = leader->m_nonInlinedPictureAnchors.begin(); it !=  leader->m_nonInlinedPictureAnchors.end(); ++it )
    {
        if ( (*it).key == key )
        {
            kdDebug(30508) << "Found pseudo-anchor for non-inlined picture: " << (*it).key.toString() << endl;
            (*it).picture.koStoreName = name;
            found = true;
        }
    }
    
    if ( !found )
    {
        kdWarning (30508) << "Could not find any anchor for picture " << key.toString() << endl;
    }

    AllowNoSubtags (myNode, leader);
}


static void ProcessPixmapsTag ( TQDomNode         myNode,
                                void            *tagData,
                                KWEFKWordLeader *leader )
{
    AllowNoAttributes (myNode);

    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList << TagProcessing ( "KEY", ProcessPixmapsKeyTag, tagData );
    ProcessSubtags (myNode, tagProcessingList, leader);
}


static void FreeCellParaLists ( TQValueList<ParaData> &paraList )
{
    TQValueList<ParaData>::Iterator paraIt;

    for ( paraIt = paraList.begin (); paraIt != paraList.end (); ++paraIt )
    {
        ValueListFormatData::Iterator formattingIt;

        for ( formattingIt = (*paraIt).formattingList.begin ();
              formattingIt != (*paraIt).formattingList.end ();
              formattingIt++ )
        {
            if ( (*formattingIt).id == 6 && (*formattingIt).frameAnchor.type == 6 )
            {
                TQValueList<TableCell>::Iterator cellIt;

                for ( cellIt = (*formattingIt).frameAnchor.table.cellList.begin ();
                      cellIt != (*formattingIt).frameAnchor.table.cellList.end ();
                      cellIt++ )
                {
                    FreeCellParaLists ( *(*cellIt).paraList );   // recursion is great
                    delete (*cellIt).paraList;
                }
            }
        }
    }
}

// like ProcessFramesetTag, but only handle footnotes
static void ProcessFootnoteFramesetTag ( TQDomNode myNode, void *tagData, KWEFKWordLeader *leader )
{
    TQString frameName;
    int frameType = -1, frameInfo = -1;
    bool visible = false;

    TQValueList<AttrProcessing> attrProcessingList;
    attrProcessingList
        << AttrProcessing ( "name",        frameName      )
        << AttrProcessing ( "frameType",   frameType )
        << AttrProcessing ( "frameInfo",   frameInfo )
        << AttrProcessing ( "removable" )
        << AttrProcessing ( "visible",     visible )
        << AttrProcessing ( "grpMgr" )
        << AttrProcessing ( "row" )
        << AttrProcessing ( "col" )
        << AttrProcessing ( "rows" )
        << AttrProcessing ( "cols" )
        << AttrProcessing ( "protectSize" )
        ;
    ProcessAttributes (myNode, attrProcessingList);

    // for footnote frame, frameType is 1 and frameInfo is 7
    if( ( frameType == 1 ) && ( frameInfo == 7 ) )
    {
        FootnoteData footnote;
        footnote.frameName = frameName;
        TQValueList<TagProcessing> tagProcessingList;
        tagProcessingList.append(TagProcessing ( "FRAME" ));
        tagProcessingList.append(TagProcessing ( "PARAGRAPH", ProcessParagraphTag,  &footnote.para ));
        ProcessSubtags (myNode, tagProcessingList, leader);
        leader->footnoteList.append( footnote );
    }
}

// like ProcessFramesetsTag, but only handle footnotes
static void ProcessFootnoteFramesetsTag ( TQDomNode myNode, void *tagData, KWEFKWordLeader *leader )
{
    AllowNoAttributes (myNode);

    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList << TagProcessing ( "FRAMESET", ProcessFootnoteFramesetTag, tagData );
    ProcessSubtags (myNode, tagProcessingList, leader);
}

static void ProcessBookmarkItemTag ( TQDomNode myNode, void* tag, KWEFKWordLeader *leader )
{
    TQValueList<Bookmark> * bookmarkList = static_cast< TQValueList<Bookmark> * > ( tag );

    Bookmark bookmark;

    TQValueList<AttrProcessing> attrProcessingList;
    attrProcessingList
        << AttrProcessing ( "name", bookmark.m_name )
        << AttrProcessing ( "cursorIndexStart", bookmark.m_cursorIndexStart )
        << AttrProcessing ( "cursorIndexEnd", bookmark.m_cursorIndexEnd )
        << AttrProcessing ( "frameset", bookmark.m_frameset )
        << AttrProcessing ( "startparag", bookmark.m_startparag )
        << AttrProcessing ( "endparag", bookmark.m_endparag )
        ;

    ProcessAttributes (myNode, attrProcessingList);

    AllowNoSubtags( myNode, leader );
    
    // ### TODO: some verifications

    kdDebug(30508) << "Bookmark: " << bookmark.m_name << " in frameset " << bookmark.m_frameset << endl;

    bookmarkList->append( bookmark );
}

static void ProcessBookmarksTag ( TQDomNode myNode, void* tag, KWEFKWordLeader *leader )
{
    AllowNoAttributes (myNode);

    TQValueList<TagProcessing> tagProcessingList;
    tagProcessingList << TagProcessing ( "BOOKMARKITEM", ProcessBookmarkItemTag, tag );
    ProcessSubtags (myNode, tagProcessingList, leader);
}

void ProcessDocTag ( TQDomNode         myNode,
    void* /*tagData*/, KWEFKWordLeader* leader )
{
    //kdDebug (30508) << "Entering ProcessDocTag" << endl;

    TQString editor, author;
    
    TQValueList<AttrProcessing> attrProcessingList;

    attrProcessingList
        << AttrProcessing ( "xmlns" )
        << AttrProcessing ( "editor", editor )
        << AttrProcessing ( "mime" )
        << AttrProcessing ( "syntaxVersion", leader->m_syntaxVersion )
        << AttrProcessing ( "author", author )
        << AttrProcessing ( "email" )
        ;

    ProcessAttributes( myNode, attrProcessingList );

    kdDebug(30508) << "Document written by " << editor << endl;
    kdDebug(30508) << "Document of syntax version " << leader->m_syntaxVersion << endl;

    if ( leader->m_syntaxVersion == 1 )
    {
        leader->m_oldSyntax = true; // Syntax 1 is old syntax
    }
    else if ( leader->m_syntaxVersion == -1 )
    {
        // We do not know the version, but it still might be an old syntax.
        // However such old documents have still an author attribute, so check its value
        if ( author == "Reginald Stadlbauer and Torben Weis" )
        {
            kdDebug(30508) << "No syntax version but author attribute matches => assuming old syntax" << endl;
            leader->m_oldSyntax = true;
        }
        else
        {
            kdWarning(30508) << "No syntax version found, author attribute does not match => assuming new syntax" << endl;
        }
    }

    leader->doOpenHead();

    // At first, process <SPELLCHECKIGNORELIST>, even if mostly it will not be needed
    TQDomNode nodeIgnoreList=myNode.namedItem("SPELLCHECKIGNORELIST");
    if ( nodeIgnoreList.isNull () )
        kdDebug (30508) << "No <SPELLCHECKIGNORELIST>" << endl; // Most files will not have it!
    else
        ProcessSpellCheckIgnoreListTag (nodeIgnoreList, NULL, leader);

    // Process <PAPER> now, even if mostly the output will need to be delayed.
    TQDomNode nodePaper=myNode.namedItem("PAPER");
    if ( nodePaper.isNull () )
        kdWarning (30508) << "No <PAPER>" << endl;
    else
        ProcessPaperTag (nodePaper, NULL, leader);

    // Process <VARIABLESETTINGS>
    TQDomNode nodeVariableSettings=myNode.namedItem("VARIABLESETTINGS");
    if ( nodeVariableSettings.isNull () )
	kdWarning (30508) << "No <VARIABLESETTINGS>" << endl;
    else
	ProcessVariableSettingsTag (nodeVariableSettings, NULL, leader);

    // Then we process the styles
    TQDomNode nodeStyles=myNode.namedItem("STYLES");
    if ( nodeStyles.isNull () )
        kdWarning (30508) << "No <STYLES>" << endl;
    else
        ProcessStylesPluralTag (nodeStyles, NULL, leader);

    // Process framesets, but only to find and extract footnotes (also endnotes)
    TQValueList<FootnoteData> footnotes;
    TQDomNode nodeFramesets=myNode.namedItem("FRAMESETS");
    if ( !nodeFramesets.isNull() )
        ProcessFootnoteFramesetsTag(nodeFramesets, &footnotes, leader );

    // Process all framesets and pictures
    TQValueList<TagProcessing> tagProcessingList;
    TQValueList<ParaData> paraList;

    tagProcessingList
        << TagProcessing ( "PAPER" ) // Already done
        << TagProcessing ( "ATTRIBUTES" )
        << TagProcessing ( "FRAMESETS",   ProcessFramesetsTag,    &paraList )
        << TagProcessing ( "STYLES" ) // Already done
        << TagProcessing ( "PICTURES",    ProcessPixmapsTag,      &paraList )
        << TagProcessing ( "PIXMAPS",     ProcessPixmapsTag,      &paraList )
        << TagProcessing ( "CLIPARTS",    ProcessPixmapsTag,      &paraList )
        << TagProcessing ( "EMBEDDED" )
        << TagProcessing ( "BOOKMARKS",   ProcessBookmarksTag,    &leader->m_bookmarkList )
        ;

    // TODO: why are the followings used by KWord 1.2 but are not in its DTD?
    tagProcessingList << TagProcessing ( "SERIALL" );
    tagProcessingList << TagProcessing ( "FOOTNOTEMGR" );

    ProcessSubtags (myNode, tagProcessingList, leader);

    leader->doCloseHead();
    leader->doDeclareNonInlinedFramesets( leader->m_nonInlinedPictureAnchors, leader->m_nonInlinedTableAnchors );
    leader->doOpenBody();

    leader->doFullDocument (paraList);

    kdDebug(30508) << "Unachored Framesets : START" << endl;
    TQStringList::ConstIterator it;
    for ( it = leader->m_unanchoredFramesets.begin(); it != leader->m_unanchoredFramesets.end(); ++it )
    {
        kdDebug(30508) << (*it) << endl;
    }
    kdDebug(30508) << "Unachored Framesets : END" << endl;
    
    FreeCellParaLists (paraList);

    leader->doCloseBody();

    //kdDebug (30508) << "Exiting ProcessDocTag" << endl;
}


void KWEFKWordLeader::setWorker ( KWEFBaseWorker *newWorker )
{
    m_worker = newWorker;

    if (newWorker)
        newWorker->registerKWordLeader(this);
}


KWEFBaseWorker *KWEFKWordLeader::getWorker(void) const
{
    return m_worker;
}


// Short simple definition for methods with void parameter
#define DO_VOID_DEFINITION(string) \
    bool KWEFKWordLeader::string() \
    {\
        if (m_worker) \
            return m_worker->string(); \
        return false; \
    }


bool KWEFKWordLeader::doOpenFile ( const TQString &filenameOut, const TQString &to )
{
    if ( m_worker )
        return m_worker->doOpenFile (filenameOut, to);

    // As it would be the first method to be called, warn if worker is NULL
    kdError (30508) << "No Worker! (in KWEFKWordLeader::doOpenFile)" << endl;

    return false;
}


DO_VOID_DEFINITION (doCloseFile)
DO_VOID_DEFINITION (doAbortFile)
DO_VOID_DEFINITION (doOpenDocument)
DO_VOID_DEFINITION (doCloseDocument)
DO_VOID_DEFINITION (doOpenStyles)
DO_VOID_DEFINITION (doCloseStyles)
DO_VOID_DEFINITION (doOpenHead)
DO_VOID_DEFINITION (doCloseHead)
DO_VOID_DEFINITION (doOpenBody)
DO_VOID_DEFINITION (doCloseBody)
DO_VOID_DEFINITION (doOpenSpellCheckIgnoreList)
DO_VOID_DEFINITION (doCloseSpellCheckIgnoreList)

bool KWEFKWordLeader::doFullDocumentInfo (const KWEFDocumentInfo &docInfo)
{
    if ( m_worker )
        return m_worker->doFullDocumentInfo (docInfo);

    return false;
}


bool KWEFKWordLeader::doVariableSettings (const VariableSettingsData &varSettings)
{
    if ( m_worker )
        return m_worker->doVariableSettings (varSettings);

    return false;
}


bool KWEFKWordLeader::doFullDocument (const TQValueList<ParaData> &paraList)
{
    if ( m_worker )
        return m_worker->doFullDocument (paraList);

    return false;
}

bool KWEFKWordLeader::doPageInfo ( const int headerType, const int footerType )
{
    if ( m_worker )
        return m_worker->doPageInfo ( headerType, footerType );

    return false;
}

bool KWEFKWordLeader::doFullPaperFormat ( const int format, const double width, const double height, const int orientation )
{
    if ( m_worker )
        return m_worker->doFullPaperFormat (format, width, height, orientation);

    return false;
}

bool KWEFKWordLeader::doFullPaperBorders (const double top, const double left, const double bottom, const double right)
{
    if ( m_worker )
        return m_worker->doFullPaperBorders (top, left, bottom, right);

    return false;
}

bool KWEFKWordLeader::doFullPaperFormatOther ( const int columns, const double columnspacing, const int numPages )
{
    if ( m_worker )
        return m_worker->doFullPaperFormatOther ( columns, columnspacing, numPages );
    
    return false;
}

bool KWEFKWordLeader::doFullDefineStyle ( LayoutData &layout )
{
    if ( m_worker )
        return m_worker->doFullDefineStyle (layout);

    return false;
}

bool KWEFKWordLeader::doFullSpellCheckIgnoreWord (const TQString& ignoreword)
{
    if ( m_worker )
        return m_worker->doFullSpellCheckIgnoreWord (ignoreword);

    return false;
}

bool KWEFKWordLeader::doHeader ( const HeaderData& header )
{
    if ( m_worker )
        return m_worker->doHeader (header);

    return false;
}

bool KWEFKWordLeader::doFooter ( const FooterData& footer )
{
    if ( m_worker )
        return m_worker->doFooter (footer);

    return false;
}

bool KWEFKWordLeader::doDeclareNonInlinedFramesets( TQValueList<FrameAnchor>& pictureAnchors, TQValueList<FrameAnchor>& tableAnchors )
{
    if ( m_worker )
        return m_worker->doDeclareNonInlinedFramesets( pictureAnchors, tableAnchors );

    return false;
}

static bool ParseFile ( TQIODevice* subFile, TQDomDocument& doc)
{
    TQString errorMsg;
    int errorLine;
    int errorColumn;

    if ( !doc.setContent (subFile, &errorMsg, &errorLine, &errorColumn) )
    {
        kdError (30508) << "Parsing Error! Aborting! (in ParseFile)" << endl
            << "  Line: " << errorLine << " Column: " << errorColumn << endl
            << "  Message: " << errorMsg << endl;
        // ### TODO: the error is in which sub-file?
        KMessageBox::error( 0L, i18n("An error has occurred while parsing the KWord file.\nAt line: %1, column %2\nError message: %3")
            .arg( errorLine ).arg( errorColumn ).arg(i18n( "TQXml", errorMsg.utf8() ) ),
            i18n("KWord Export Filter Library"), 0 );
        return false;
    }
    return true;
}

static bool ProcessStoreFile ( TQIODevice* subFile,
    void (*processor) (TQDomNode, void *, KWEFKWordLeader *),
    KWEFKWordLeader* leader)
{
    if (!subFile)
    {
        kdWarning(30508) << "Could not get a device for the document!" << endl;
    }
    else if ( subFile->open ( IO_ReadOnly ) )
    {
        kdDebug (30508) << "Processing Document..." << endl;
        TQDomDocument doc;
        if (!ParseFile(subFile, doc))
        {
            subFile->close();
            return false;
        }
        // We must close the subFile before processing,
        //  as the processing could open other sub files.
        //  However, it would crash if two sub files are opened together
        subFile->close();

        TQDomNode docNode = doc.documentElement();
        processor (docNode, NULL, leader);
        return true;
    }
    else
    {
        // Note: we do not worry too much if we cannot open the document info!
        kdWarning (30508) << "Unable to open document!" << endl;
    }
    return false;
}

TQIODevice* KWEFKWordLeader::getSubFileDevice(const TQString& fileName)
{
    KoStoreDevice* subFile;

    subFile=m_chain->storageFile(fileName,KoStore::Read);

    if (!subFile)
    {
        kdError(30508) << "Could not get a device for sub-file: " << fileName << endl;
        return NULL;
    }
    return subFile;
}


bool KWEFKWordLeader::loadSubFile(const TQString& fileName, TQByteArray& array)
{
    KoStoreDevice* subFile;

    subFile=m_chain->storageFile(fileName,KoStore::Read);

    if (!subFile)
    {
        kdError(30508) << "Could not get a device for sub-file: " << fileName << endl;
        return false;
    }
    else if ( subFile->open ( IO_ReadOnly ) )
    {
        array = subFile->readAll();
        subFile->close ();
    }
    else
    {
        kdError(30508) << "Unable to open " << fileName << " sub-file" << endl;
        return false;
    }

    return true;
}

KoFilter::ConversionStatus KWEFKWordLeader::convert( KoFilterChain* chain,
    const TQCString& from, const TQCString& to)
{
    if ( from != "application/x-kword" )
    {
        return KoFilter::NotImplemented;
    }

    if (!chain)
    {
        kdError(30508) << "'Chain' is NULL! Internal error of the filter system?" << endl;
        return KoFilter::StupidError;
    }

    m_chain=chain;

    if ( !doOpenFile (chain->outputFile(),to) )
    {
        kdError (30508) << "Worker could not open export file! Aborting!" << endl;
        return KoFilter::StupidError;
    }

    if ( !doOpenDocument () )
    {
        kdError (30508) << "Worker could not open document! Aborting!" << endl;
        doAbortFile ();
        return KoFilter::StupidError;
    }

    KoStoreDevice* subFile;

    subFile=chain->storageFile("documentinfo.xml",KoStore::Read);
    kdDebug (30508) << "Processing documentinfo.xml..." << endl;
    // Do not care if we cannot open the document info.
    ProcessStoreFile (subFile, ProcessDocumentInfoTag, this);

    subFile=chain->storageFile("root",KoStore::Read);
    kdDebug (30508) << "Processing root..." << endl;
    if (!ProcessStoreFile (subFile, ProcessDocTag, this))
    {
        kdWarning(30508) << "Opening root has failed. Trying raw XML file!" << endl;

        const TQString filename( chain->inputFile() );
        if (filename.isEmpty() )
        {
            kdError(30508) << "Could not open document as raw XML! Aborting!" << endl;
            doAbortFile();
            return KoFilter::StupidError;
        }
        else
        {
            TQFile file( filename );
            if ( ! ProcessStoreFile( TQT_TQIODEVICE(&file), ProcessDocTag, this ) )
            {
                kdError(30508) << "Could not process document! Aborting!" << endl;
                doAbortFile();
                return KoFilter::StupidError;
            }
        }
    }
    
    doCloseDocument ();

    doCloseFile ();

    return KoFilter::OK;
}
