Added old abandoned KDE3 version of koffice

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1077364 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 2094 insertions, 0 deletions

diff --git a/kword/KWCommand.cpp b/kword/KWCommand.cpp
new file mode 100644
index 000000000..52383db4f
--- /dev/null
+++ b/kword/KWCommand.cpp
@@ -0,0 +1,2094 @@
+/* This file is part of the KDE project
+   Copyright (C) 2001 David Faure <faure@kde.org>
+   Copyright (C) 2005 Thomas Zander <zander@kde.org>
+
+   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.
+*/
+
+#include "KWCommand.h"
+#include "KWDocument.h"
+#include "KWTextFrameSet.h"
+#include "KWTableStyle.h"
+#include "KWTableTemplate.h"
+#include "KWTableFrameSet.h"
+#include "KWPartFrameSet.h"
+#include "KWTextDocument.h"
+#include "KWTextParag.h"
+#include "KWAnchor.h"
+#include "KWVariable.h"
+#include "KWOasisLoader.h"
+#include "KWFrameList.h"
+#include "KWFrameSet.h"
+#include "KWPictureFrameSet.h"
+#include "KWPageManager.h"
+#include "KWPage.h"
+
+#include <KoTextObject.h>
+#include <KoOasisStyles.h>
+#include <KoOasisContext.h>
+#include <KoXmlNS.h>
+#include <KoDom.h>
+#include <KoStore.h>
+#include <KoOasisStore.h>
+
+#include <klocale.h>
+#include <kdebug.h>
+
+#include <qxml.h>
+#include <qbuffer.h>
+#include <algorithm>
+
+// Helper class for deleting all custom items
+// (KWTextFrameset::removeSelectedText and readFormats do that already,
+//  but with undo/redo, and copying all formatting etc.)
+class KWDeleteCustomItemVisitor : public KoParagVisitor // see kotextdocument.h
+{
+public:
+    KWDeleteCustomItemVisitor() : KoParagVisitor() { }
+    virtual bool visit( KoTextParag *parag, int start, int end )
+    {
+        kdDebug(32001) << "KWPasteTextCommand::execute " << parag->paragId() << " " << start << " " << end << endl;
+        for ( int i = start ; i < end ; ++i )
+        {
+            KoTextStringChar * ch = parag->at( i );
+            if ( ch->isCustom() ) {
+                KoTextCustomItem* item = ch->customItem();
+                item->setDeleted( true );
+                parag->removeCustomItem(i);
+                KCommand* itemCmd = item->deleteCommand();
+                if ( itemCmd )
+                    itemCmd->execute();
+            }
+        }
+        return true;
+    }
+};
+
+#if 0 // kept for comparison with KWOasisPasteCommand
+KWPasteTextCommand::KWPasteTextCommand( KoTextDocument *d, int parag, int idx,
+                                const QCString & data )
+    : KoTextDocCommand( d ), m_parag( parag ), m_idx( idx ), m_data( data ), m_oldParagLayout( 0 )
+{
+}
+
+KoTextCursor * KWPasteTextCommand::execute( KoTextCursor *c )
+{
+    KoTextParag *firstParag = doc->paragAt( m_parag );
+    if ( !firstParag ) {
+        qWarning( "can't locate parag at %d, last parag: %d", m_parag, doc->lastParag()->paragId() );
+        return 0;
+    }
+    //kdDebug() << "KWPasteTextCommand::execute m_parag=" << m_parag << " m_idx=" << m_idx
+    //          << " firstParag=" << firstParag << " " << firstParag->paragId() << endl;
+    cursor.setParag( firstParag );
+    cursor.setIndex( m_idx );
+    c->setParag( firstParag );
+    c->setIndex( m_idx );
+    QDomDocument domDoc;
+    domDoc.setContent( m_data );
+    QDomElement elem = domDoc.documentElement();
+    KWTextDocument * textdoc = static_cast<KWTextDocument *>(doc);
+    KWTextFrameSet * textFs = textdoc->textFrameSet();
+    // We iterate twice over the list of paragraphs.
+    // First time to gather the text,
+    // second time to apply the character & paragraph formatting
+    QString text;
+
+    QValueList<QDomElement> listParagraphs;
+    QDomElement paragraph = elem.firstChild().toElement();
+    for ( ; !paragraph.isNull() ; paragraph = paragraph.nextSibling().toElement() )
+    {
+        if ( paragraph.tagName() == "PARAGRAPH" )
+        {
+            QString s = paragraph.namedItem( "TEXT" ).toElement().text();
+            //kdDebug() << "KWPasteTextCommand::execute Inserting text: '" << s << "'" << endl;
+            c->insert( s, false /*newline=linebreak, not new parag*/ );
+
+            if ( !paragraph.nextSibling().isNull() ) // Not for last parag
+            {
+                // Create new parag
+                // Lowlevel method:
+                c->splitAndInsertEmptyParag( FALSE, TRUE );
+                // Highlevel method:
+                //c->insert( "\n", true );
+            }
+            listParagraphs.append( paragraph );
+        }
+    }
+
+    // Redo the parag lookup because if firstParag was empty, insert() has
+    // shifted it down (side effect of splitAndInsertEmptyParag)
+    firstParag = doc->paragAt( m_parag );
+    KWTextParag * parag = static_cast<KWTextParag *>(firstParag);
+    //kdDebug() << "KWPasteTextCommand::execute starting at parag " << parag << " " << parag->paragId() << endl;
+    uint count = listParagraphs.count();
+    QValueList<QDomElement>::Iterator it = listParagraphs.begin();
+    QValueList<QDomElement>::Iterator end = listParagraphs.end();
+    for ( uint item = 0 ; it != end ; ++it, ++item )
+    {
+        if (!parag)
+        {
+            kdWarning() << "KWPasteTextCommand: parag==0L ! KWord bug, please report." << endl;
+            break;
+        }
+        QDomElement paragElem = *it;
+        // First line (if appending to non-empty line) : apply offset to formatting, don't apply parag layout
+        if ( item == 0 && m_idx > 0 )
+        {
+            // First load the default format, but only apply it to our new chars
+            QDomElement layout = paragElem.namedItem( "LAYOUT" ).toElement();
+            if ( !layout.isNull() )
+            {
+                QDomElement formatElem = layout.namedItem( "FORMAT" ).toElement();
+                if ( !formatElem.isNull() )
+                {
+                    KoTextFormat f = parag->loadFormat( formatElem, 0L, QFont(), KGlobal::locale()->language(),false );
+                    KoTextFormat * defaultFormat = doc->formatCollection()->format( &f );
+                    // Last paragraph (i.e. only one in all) : some of the text might be from before the paste
+                    int endIndex = (item == count-1) ? c->index() : parag->string()->length() - 1;
+                    parag->setFormat( m_idx, endIndex - m_idx, defaultFormat, TRUE );
+                }
+            }
+
+            parag->loadFormatting( paragElem, m_idx, (textFs->isMainFrameset()));
+        }
+        else
+        {
+            if ( item == 0 ) // This paragraph existed, store its parag layout
+            {
+                delete m_oldParagLayout;
+                m_oldParagLayout = new KoParagLayout( parag->paragLayout() );
+            }
+            parag->loadLayout( paragElem );
+            // Last paragraph: some of the text might be from before the paste
+            int len = (item == count-1) ? c->index() : parag->string()->length();
+            // Apply default format
+            parag->setFormat( 0, len, parag->paragFormat(), TRUE );
+            parag->loadFormatting( paragElem, 0, (textFs->isMainFrameset()) );
+        }
+        parag->invalidate(0); // the formatting will be done by caller (either KWTextFrameSet::pasteOasis or KoTextObject::undo/redo)
+        parag->setChanged( TRUE );
+        parag = static_cast<KWTextParag *>(parag->next());
+        //kdDebug() << "KWPasteTextCommand::execute going to next parag: " << parag << endl;
+    }
+    textFs->textObject()->setNeedSpellCheck( true );
+    // In case loadFormatting queued any image request
+    KWDocument * doc = textFs->kWordDocument();
+    doc->processPictureRequests();
+
+    //kdDebug() << "KWPasteTextCommand::execute calling doc->pasteFrames" << endl;
+    // In case of any inline frameset
+    doc->pasteFrames( elem, 0,
+                      true /*don't change footnote attribute*/ ,
+                      (textFs->isMainFrameset()) /*load footnotes if mainframeset*/,
+                      false /*don't select frames*/ );
+    doc->completePasting();
+
+    m_lastParag = c->parag()->paragId();
+    m_lastIndex = c->index();
+    return c;
+}
+
+KoTextCursor * KWPasteTextCommand::unexecute( KoTextCursor *c )
+{
+    KoTextParag *firstParag = doc->paragAt( m_parag );
+    if ( !firstParag ) {
+        qWarning( "can't locate parag at %d, last parag: %d", m_parag, doc->lastParag()->paragId() );
+        return 0;
+    }
+    cursor.setParag( firstParag );
+    cursor.setIndex( m_idx );
+    doc->setSelectionStart( KoTextDocument::Temp, &cursor );
+
+    KoTextParag *lastParag = doc->paragAt( m_lastParag );
+    if ( !lastParag ) {
+        qWarning( "can't locate parag at %d, last parag: %d", m_lastParag, doc->lastParag()->paragId() );
+        return 0;
+    }
+    Q_ASSERT( lastParag->document() );
+    KWTextDocument * textdoc = static_cast<KWTextDocument *>(doc);
+
+    //kdDebug() << "Undoing paste: deleting from (" << firstParag->paragId() << "," << m_idx << ")"
+    //          << " to (" << lastParag->paragId() << "," << m_lastIndex << ")" << endl;
+
+    cursor.setParag( lastParag );
+    cursor.setIndex( m_lastIndex );
+    doc->setSelectionEnd( KoTextDocument::Temp, &cursor );
+    // Delete all custom items
+    KWDeleteCustomItemVisitor visitor;
+    doc->visitSelection( KoTextDocument::Temp, &visitor );
+
+    doc->removeSelectedText( KoTextDocument::Temp, c /* sets c to the correct position */ );
+
+    KWTextFrameSet * textFs = textdoc->textFrameSet();
+
+    textFs->renumberFootNotes();
+    if ( m_idx == 0 ) {
+        Q_ASSERT( m_oldParagLayout );
+        if ( m_oldParagLayout )
+            firstParag->setParagLayout( *m_oldParagLayout );
+    }
+    return c;
+}
+#endif
+
+KWOasisPasteCommand::KWOasisPasteCommand( KoTextDocument *d, int parag, int idx,
+                                const QByteArray& data )
+    : KoTextDocCommand( d ), m_parag( parag ), m_idx( idx ), m_data( data ), m_oldParagLayout( 0 )
+{
+}
+
+KoTextCursor * KWOasisPasteCommand::execute( KoTextCursor *c )
+{
+    KoTextParag *firstParag = doc->paragAt( m_parag );
+    if ( !firstParag ) {
+        qWarning( "can't locate parag at %d, last parag: %d", m_parag, doc->lastParag()->paragId() );
+        return c;
+    }
+    //kdDebug() << "KWOasisPasteCommand::execute m_parag=" << m_parag << " m_idx=" << m_idx
+    //          << " firstParag=" << firstParag << " " << firstParag->paragId() << endl;
+    cursor.setParag( firstParag );
+    cursor.setIndex( m_idx );
+    c->setParag( firstParag );
+    c->setIndex( m_idx );
+
+    KWTextDocument * textdoc = static_cast<KWTextDocument *>(doc);
+
+    QBuffer buffer( m_data );
+
+    KoStore * store = KoStore::createStore( &buffer, KoStore::Read );
+    KWDocument* kwdoc = textdoc->textFrameSet()->kWordDocument();
+    KWOasisLoader loader( kwdoc );
+    loader.insertOasisData( store, c );
+
+    delete store;
+
+    m_lastParag = c->parag()->paragId();
+    m_lastIndex = c->index();
+    return c;
+}
+
+KoTextCursor * KWOasisPasteCommand::unexecute( KoTextCursor *c )
+{
+    KoTextParag *firstParag = doc->paragAt( m_parag );
+    if ( !firstParag ) {
+        qWarning( "can't locate parag at %d, last parag: %d", m_parag, doc->lastParag()->paragId() );
+        return 0;
+    }
+    cursor.setParag( firstParag );
+    cursor.setIndex( m_idx );
+    doc->setSelectionStart( KoTextDocument::Temp, &cursor );
+
+    KoTextParag *lastParag = doc->paragAt( m_lastParag );
+    if ( !lastParag ) {
+        qWarning( "can't locate parag at %d, last parag: %d", m_lastParag, doc->lastParag()->paragId() );
+        return 0;
+    }
+    Q_ASSERT( lastParag->document() );
+    // Get hold of the document before deleting the parag
+    KWTextDocument * textdoc = static_cast<KWTextDocument *>(doc);
+
+    //kdDebug() << "Undoing paste: deleting from (" << firstParag->paragId() << "," << m_idx << ")"
+    //          << " to (" << lastParag->paragId() << "," << m_lastIndex << ")" << endl;
+
+    cursor.setParag( lastParag );
+    cursor.setIndex( m_lastIndex );
+    doc->setSelectionEnd( KoTextDocument::Temp, &cursor );
+    // Delete all custom items
+    KWDeleteCustomItemVisitor visitor;
+    doc->visitSelection( KoTextDocument::Temp, &visitor );
+
+    doc->removeSelectedText( KoTextDocument::Temp, c /* sets c to the correct position */ );
+
+    KWTextFrameSet * textFs = textdoc->textFrameSet();
+
+    textFs->renumberFootNotes();
+#if 0
+    if ( m_idx == 0 ) {
+        Q_ASSERT( m_oldParagLayout );
+        if ( m_oldParagLayout )
+            firstParag->setParagLayout( *m_oldParagLayout );
+    }
+#endif
+    return c;
+}
+
+
+KWTextDeleteCommand::KWTextDeleteCommand( KoTextDocument *d, int i, int idx, const QMemArray<KoTextStringChar> &str,
+                         const CustomItemsMap & customItemsMap,
+                         const QValueList<KoParagLayout> & oldParagLayouts )
+    :KoTextDeleteCommand(d, i, idx, str, customItemsMap, oldParagLayouts)
+{
+    //createBookmarkList();
+}
+
+void KWTextDeleteCommand::createBookmarkList()
+{
+#if 0
+    KoTextParag *s = doc ? doc->paragAt( id ) : parag;
+    if ( !s ) {
+        qWarning( "can't locate parag at %d, last parag: %d", id, doc->lastParag()->paragId() );
+        return;
+    }
+
+    // Now restore the parag layouts (i.e. libkotext specific stuff)
+    QValueList<KoParagLayout>::Iterator lit = m_oldParagLayouts.begin();
+    kdDebug(32500) << "KWTextDeleteCommand::createBookmarkList " << m_oldParagLayouts.count() << " parag layouts. First parag=" << s->paragId() << endl;
+    Q_ASSERT( id == s->paragId() );
+    KoTextParag *p = s;
+    while ( p ) {
+        if ( lit != m_oldParagLayouts.end() )
+        {
+            kdDebug(32500) << "KWTextDeleteCommand::unexecute find bookmark in parag " << p->paragId() << endl;
+            //p->setParagLayout( *lit );
+        }
+        else
+            break;
+        p = p->next();
+        ++lit;
+    }
+#endif
+}
+
+KoTextCursor *KWTextDeleteCommand::execute( KoTextCursor *c )
+{
+    return KoTextDeleteCommand::execute( c );
+}
+
+KoTextCursor *KWTextDeleteCommand::unexecute( KoTextCursor *c )
+{
+    return KoTextDeleteCommand::unexecute( c );
+}
+
+////////////////////////// Frame commands ////////////////////////////////
+
+FrameIndex::FrameIndex( KWFrame *frame )
+{
+    m_pFrameSet=frame->frameSet();
+    m_iFrameIndex=m_pFrameSet->frameFromPtr(frame);
+}
+
+KWFrameBorderCommand::KWFrameBorderCommand( const QString &name, QPtrList<FrameIndex> &_listFrameIndex, QPtrList<FrameBorderTypeStruct> &_frameTypeBorder,const KoBorder & _newBorder):
+    KNamedCommand(name),
+    m_indexFrame(_listFrameIndex),
+    m_oldBorderFrameType(_frameTypeBorder),
+    m_newBorder( _newBorder)
+{
+}
+
+KWFrameBorderCommand::~KWFrameBorderCommand()
+{
+    m_indexFrame.setAutoDelete( true);
+    m_oldBorderFrameType.setAutoDelete( true);
+}
+
+void KWFrameBorderCommand::execute()
+{
+    FrameIndex *tmp;
+    KWDocument *doc = 0L;
+    for ( tmp=m_indexFrame.first(); tmp != 0; tmp=m_indexFrame.next() )
+    {
+        KWFrameSet *frameSet =tmp->m_pFrameSet;
+        doc = frameSet->kWordDocument();
+        KWFrame *frame=frameSet->frame(tmp->m_iFrameIndex);
+        KWTableFrameSet::Cell *cell = dynamic_cast<KWTableFrameSet::Cell *>(frame->frameSet());
+        FrameBorderTypeStruct *tmpFrameStruct=m_oldBorderFrameType.at(m_indexFrame.find(tmp));
+
+        switch( tmpFrameStruct->m_EFrameType)
+        {
+            case KoBorder::LeftBorder:
+                if(cell) // is a table cell
+                    cell->setLeftBorder(m_newBorder);
+                else
+                    frame->setLeftBorder(m_newBorder);
+                break;
+            case KoBorder::RightBorder:
+                if(cell) // is a table cell
+                    cell->setRightBorder(m_newBorder);
+                else
+                     frame->setRightBorder(m_newBorder);
+                break;
+            case KoBorder::TopBorder:
+                if(cell) // is a table cell
+                    cell->setTopBorder(m_newBorder);
+                else
+                      frame->setTopBorder(m_newBorder);
+                break;
+            case KoBorder::BottomBorder:
+                if(cell) // is a table cell
+                    cell->setBottomBorder(m_newBorder);
+                else
+                    frame->setBottomBorder(m_newBorder);
+                break;
+            default:
+                break;
+        }
+
+        if (!cell) {
+            frame->frameBordersChanged();
+            //fixme frameBorderChanged for table cells here too ?
+        }
+    }
+
+
+    if ( doc )
+    {
+        doc->repaintAllViews();
+    }
+}
+
+void KWFrameBorderCommand::unexecute()
+{
+    FrameIndex *tmp;
+    KWDocument *doc = 0L;
+    for ( tmp=m_indexFrame.first(); tmp != 0; tmp=m_indexFrame.next() )
+    {
+        KWFrameSet *frameSet =tmp->m_pFrameSet;
+        doc = frameSet->kWordDocument();
+        KWFrame *frame=frameSet->frame(tmp->m_iFrameIndex);
+        KWTableFrameSet::Cell *cell = dynamic_cast<KWTableFrameSet::Cell *>(frame->frameSet());
+        FrameBorderTypeStruct *tmpFrameStruct=m_oldBorderFrameType.at(m_indexFrame.find(tmp));
+        switch(tmpFrameStruct->m_EFrameType)
+        {
+            case KoBorder::LeftBorder:
+                if(cell) // is a table cell
+                    cell->setLeftBorder(tmpFrameStruct->m_OldBorder);
+                else
+                    frame->setLeftBorder(tmpFrameStruct->m_OldBorder);
+                break;
+            case KoBorder::RightBorder:
+                if(cell) // is a table cell
+                    cell->setRightBorder(tmpFrameStruct->m_OldBorder);
+                else
+                    frame->setRightBorder(tmpFrameStruct->m_OldBorder);
+                break;
+            case KoBorder::TopBorder:
+                if(cell) // is a table cell
+                    cell->setTopBorder(tmpFrameStruct->m_OldBorder);
+                else
+                    frame->setTopBorder(tmpFrameStruct->m_OldBorder);
+                break;
+            case KoBorder::BottomBorder:
+                if(cell) // is a table cell
+                    cell->setBottomBorder(tmpFrameStruct->m_OldBorder);
+                else
+                    frame->setBottomBorder(tmpFrameStruct->m_OldBorder);
+                break;
+            default:
+                break;
+        }
+        if (!cell) {
+            frame->frameBordersChanged();
+            //fixme frameBorderChanged for table cells here too ?
+        }
+    }
+
+
+
+    if ( doc )
+    {
+        //update frames
+        doc->repaintAllViews();
+    }
+}
+
+KWFrameBackGroundColorCommand::KWFrameBackGroundColorCommand( const QString &name, QPtrList<FrameIndex> &_listFrameIndex, QPtrList<QBrush> &_oldBrush,const QBrush & _newColor ):
+    KNamedCommand(name),
+    m_indexFrame(_listFrameIndex),
+    m_oldBackGroundColor(_oldBrush),
+    m_newColor( _newColor)
+{
+}
+
+KWFrameBackGroundColorCommand::~KWFrameBackGroundColorCommand()
+{
+    m_indexFrame.setAutoDelete(true);
+    m_oldBackGroundColor.setAutoDelete(true);
+}
+
+
+void KWFrameBackGroundColorCommand::execute()
+{
+    FrameIndex *tmp;
+    KWDocument * doc = 0L;
+    for ( tmp=m_indexFrame.first(); tmp != 0; tmp=m_indexFrame.next() )
+    {
+        KWFrameSet *frameSet =tmp->m_pFrameSet;
+        if ( frameSet && (frameSet->type() != FT_PICTURE) && (frameSet->type() != FT_PART))
+        {
+            doc = frameSet->kWordDocument();
+            KWFrame *frame=frameSet->frame(tmp->m_iFrameIndex);
+            frame->setBackgroundColor(m_newColor);
+        }
+    }
+    //update frame
+    if ( doc )
+        doc->repaintAllViews();
+}
+
+void KWFrameBackGroundColorCommand::unexecute()
+{
+    FrameIndex *tmp;
+    KWDocument * doc = 0L;
+    for ( tmp=m_indexFrame.first(); tmp != 0; tmp=m_indexFrame.next() )
+    {
+        KWFrameSet *frameSet =tmp->m_pFrameSet;
+        if ( frameSet && (frameSet->type() != FT_PICTURE) && (frameSet->type() != FT_PART) )
+        {
+            doc = frameSet->kWordDocument();
+            KWFrame *frame=frameSet->frame(tmp->m_iFrameIndex);
+            QBrush *tmpFrameStruct=m_oldBackGroundColor.at(m_indexFrame.find(tmp));
+            frame->setBackgroundColor(*tmpFrameStruct);
+        }
+    }
+
+    //update frames
+    if ( doc )
+        doc->repaintAllViews();
+}
+
+KWFrameStyleCommand::KWFrameStyleCommand( const QString &name, KWFrame *_frame, KWFrameStyle *_fs, bool _repaintViews ) :
+    KNamedCommand( name )
+{
+    m_frame = _frame;
+    m_fs = _fs;
+    repaintViews = _repaintViews;
+
+    m_oldValues = new KWFrameStyle( "Old", m_frame );
+}
+
+void KWFrameStyleCommand::execute()
+{
+    applyFrameStyle( m_fs);
+}
+
+void KWFrameStyleCommand::unexecute()
+{
+    applyFrameStyle( m_oldValues);
+}
+
+void KWFrameStyleCommand::applyFrameStyle( KWFrameStyle * _sty )
+{
+    if ( m_frame->frameSet() && (m_frame->frameSet()->type() != FT_PICTURE)&& (m_frame->frameSet()->type() != FT_PART))
+        m_frame->setBackgroundColor( _sty->backgroundColor() );
+    m_frame->setLeftBorder( _sty->leftBorder() );
+    m_frame->setRightBorder( _sty->rightBorder() );
+    m_frame->setTopBorder( _sty->topBorder() );
+    m_frame->setBottomBorder( _sty->bottomBorder() );
+
+    m_frame->frameBordersChanged();
+    if ( repaintViews )
+        m_frame->frameSet()->kWordDocument()->repaintAllViews();
+}
+
+
+KWTableStyleCommand::KWTableStyleCommand( const QString &name, KWFrame *_frame, KWTableStyle *_ts, bool _repaintViews ) :
+    KNamedCommand( name )
+{
+    m_frame = _frame;
+    m_ts = _ts;
+    repaintViews = _repaintViews;
+
+    // No need for i18n because it will never be displayed.
+    m_fsc = new KWFrameStyleCommand( "Apply Framestyle to Frame", m_frame, m_ts->frameStyle(), repaintViews );
+    m_sc = 0L;
+}
+
+KWTableStyleCommand::~KWTableStyleCommand()
+{
+    delete m_fsc;
+    delete m_sc;
+}
+
+void KWTableStyleCommand::execute()
+{
+    if (m_fsc)
+        m_fsc->execute();
+
+    if ( (m_ts) && ( m_frame->frameSet()->type() == FT_TEXT ) && ( m_ts->paragraphStyle() ) )
+    {
+        KoTextObject *textObject = ((KWTextFrameSet*)m_frame->frameSet())->textObject();
+        textObject->textDocument()->selectAll( KoTextDocument::Temp );
+        m_sc = textObject->applyStyleCommand( 0L, m_ts->paragraphStyle(), KoTextDocument::Temp, KoParagLayout::All, KoTextFormat::Format, true, false );
+        textObject->textDocument()->removeSelection( KoTextDocument::Temp );
+    }
+
+    m_frame->frameBordersChanged();
+    if ( repaintViews )
+        m_frame->frameSet()->kWordDocument()->repaintAllViews();
+
+}
+
+void KWTableStyleCommand::unexecute()
+{
+    if (m_fsc)
+        m_fsc->unexecute();
+    if (m_sc)
+        m_sc->unexecute();
+
+    m_frame->frameBordersChanged();
+    if ( repaintViews )
+        m_frame->frameSet()->kWordDocument()->repaintAllViews();
+}
+
+KWTableTemplateCommand::KWTableTemplateCommand( const QString &name, KWTableFrameSet *_table, KWTableTemplate *_tt ) :
+    KNamedCommand( name )
+{
+    m_table = _table;
+    m_tt = _tt;
+
+    // No need for i18n because it will never be displayed.
+    m_tableCommands = new KMacroCommand( "Apply Tablestyles to Table" );
+
+
+    KWTableStyle *cell = 0L;
+    unsigned int rows = m_table->getRows();
+    unsigned int cols = m_table->getColumns();
+
+    for ( unsigned int i = 0; i < rows; i++ )
+    {
+        for ( unsigned int j = 0; j < cols; j++ )
+        {
+            if ( (i==0) && (j==0) ) // TOP LEFT CORNER
+                cell = m_tt->pTopLeftCorner();
+            else
+            if ( (i==0) && ( j==(cols-1) ) ) // TOP RIGHT CORNER
+                cell = m_tt->pTopRightCorner();
+            else
+            if ( ( i==(rows-1) ) && (j==0) ) // BOTTOM LEFT CORNER
+                cell = m_tt->pBottomLeftCorner();
+            else
+            if ( ( i==(rows-1) ) && ( j==(cols-1) ) ) // BOTTOM RIGHT CORNER
+                cell = m_tt->pBottomRightCorner();
+            else
+            if ( ( i==0 ) && ( j>0 ) && ( j<(cols-1) ) ) // FIRST ROW
+                cell = m_tt->pFirstRow();
+            else
+            if ( ( j==0 ) && ( i>0 ) && ( i<(rows-1) ) ) // FIRST COL
+                cell = m_tt->pFirstCol();
+            else
+            if ( ( i==(rows-1) ) && ( j>0 ) && ( j<(cols-1) ) )  // LAST ROW
+                cell = m_tt->pLastRow();
+            else
+            if ( ( j==(cols-1) ) && ( i>0 ) && ( i<(rows-1) ) ) // LAST COL
+                cell = m_tt->pLastCol();
+            else
+            if ( (i>0) && (j>0) && (i<(rows-1)) && (j<(cols-1)) ) // BODY
+                cell = m_tt->pBodyCell();
+
+            m_tableCommands->addCommand( new KWTableStyleCommand( "Apply tablestyle to cell", m_table->cell(i,j)->frame(0),cell, false ) );
+        }
+    }
+}
+
+KWTableTemplateCommand::~KWTableTemplateCommand()
+{
+    delete m_tableCommands;
+}
+
+void KWTableTemplateCommand::execute()
+{
+    m_tableCommands->execute();
+    m_table->kWordDocument()->repaintAllViews();
+}
+
+void KWTableTemplateCommand::unexecute()
+{
+    m_tableCommands->unexecute();
+    m_table->kWordDocument()->repaintAllViews();
+}
+
+
+KWFrameResizeCommand::KWFrameResizeCommand(const QString &name, const QValueList<FrameIndex> &frameIndex, const QValueList<FrameResizeStruct> &frameResize )
+    : KNamedCommand(name), m_indexFrame(frameIndex), m_frameResize(frameResize) {
+    Q_ASSERT(m_indexFrame.count() == m_frameResize.count());
+}
+KWFrameResizeCommand::KWFrameResizeCommand(const QString &name, FrameIndex frameIndex, const FrameResizeStruct &frameResize )
+    : KNamedCommand(name) {
+    m_indexFrame.append(frameIndex);
+    m_frameResize.append(frameResize);
+}
+
+void KWFrameResizeCommand::execute()
+{
+    QValueList<FrameResizeStruct>::Iterator resizeIter = m_frameResize.begin();
+    QValueList<FrameIndex>::Iterator iter = m_indexFrame.begin();
+    for(; iter != m_indexFrame.end() && resizeIter != m_frameResize.end(); ++resizeIter, ++iter ) {
+        FrameIndex index = *iter;
+        FrameResizeStruct frs = *resizeIter;
+
+        KWFrameSet *frameSet = index.m_pFrameSet;
+        Q_ASSERT( frameSet );
+        KWFrame *frame = frameSet->frame(index.m_iFrameIndex);
+        Q_ASSERT( frame );
+        frame->setCoords(frs.newRect.left(),frs.newRect.top(),frs.newRect.right(),frs.newRect.bottom());
+        frame->setMinimumFrameHeight(frs.newMinHeight);
+        KWTableFrameSet *table = frameSet->groupmanager();
+        if (table) {
+            KWTableFrameSet::Cell *cell=dynamic_cast<KWTableFrameSet::Cell *>(frameSet);
+            if(cell) {
+                table->recalcCols(cell->firstColumn(), cell->firstRow());
+                table->recalcRows(cell->firstColumn(), cell->firstRow());
+            }
+            else {
+                table->recalcCols(0, 0);
+                table->recalcRows(0, 0);
+            }
+        }
+
+        KWDocument * doc = frameSet->kWordDocument();
+        if ( frameSet->frameSetInfo() != KWFrameSet::FI_BODY ) // header/footer/footnote
+            doc->recalcFrames();
+
+        //update frames
+        doc->frameChanged( frame );
+    }
+}
+
+void KWFrameResizeCommand::unexecute()
+{
+    QValueList<FrameResizeStruct>::Iterator resizeIter = m_frameResize.begin();
+    QValueList<FrameIndex>::Iterator iter = m_indexFrame.begin();
+    for(; iter != m_indexFrame.end() && resizeIter != m_frameResize.end(); ++resizeIter, ++iter ) {
+        FrameIndex index = *iter;
+        FrameResizeStruct frs = *resizeIter;
+        KWFrameSet *frameSet =index.m_pFrameSet;
+        Q_ASSERT( frameSet );
+        KWFrame *frame=frameSet->frame(index.m_iFrameIndex);
+        Q_ASSERT( frame );
+        frame->setCoords(frs.oldRect.left(),frs.oldRect.top(),frs.oldRect.right(),frs.oldRect.bottom());
+        frame->setMinimumFrameHeight(frs.oldMinHeight);
+        KWTableFrameSet *table = frameSet->groupmanager();
+        if (table) {
+            KWTableFrameSet::Cell *cell=dynamic_cast<KWTableFrameSet::Cell *>(frameSet);
+            if(cell) {
+                table->recalcCols(cell->firstColumn(), cell->firstRow());
+                table->recalcRows(cell->firstColumn(), cell->firstRow());
+            }
+            else {
+                table->recalcCols(0, 0);
+                table->recalcRows(0, 0);
+            }
+        }
+        KWDocument * doc = frameSet->kWordDocument();
+        if ( frameSet->frameSetInfo() != KWFrameSet::FI_BODY ) // header/footer/footnote
+            doc->recalcFrames();
+
+        frame->updateRulerHandles();
+
+        //update frames
+        doc->frameChanged( frame );
+    }
+}
+
+KWFrameChangePictureCommand::KWFrameChangePictureCommand( const QString &name, FrameIndex _frameIndex, const KoPictureKey & _oldKey, const KoPictureKey & _newKey ) :
+    KNamedCommand(name),
+    m_indexFrame(_frameIndex),
+    m_oldKey(_oldKey),
+    m_newKey(_newKey)
+{
+}
+
+void KWFrameChangePictureCommand::execute()
+{
+    KWFrameSet *frameSet = m_indexFrame.m_pFrameSet;
+    Q_ASSERT( frameSet );
+    KWFrame *frame = frameSet->frame(m_indexFrame.m_iFrameIndex);
+    Q_ASSERT( frame );
+    KWDocument * doc = frameSet->kWordDocument();
+    KWPictureFrameSet *frameset = static_cast<KWPictureFrameSet *>(frame->frameSet());
+    frameset->reloadPicture( m_newKey );
+    frameSet->kWordDocument()->refreshDocStructure( frameSet->type() );
+    doc->frameChanged( frame );
+}
+
+void KWFrameChangePictureCommand::unexecute()
+{
+    KWFrameSet *frameSet =m_indexFrame.m_pFrameSet;
+    KWFrame *frame=frameSet->frame(m_indexFrame.m_iFrameIndex);
+    KWDocument * doc = frameSet->kWordDocument();
+    KWPictureFrameSet *frameset = static_cast<KWPictureFrameSet *>(frame->frameSet());
+    frameset->reloadPicture( m_oldKey );
+    frameSet->kWordDocument()->refreshDocStructure( frameSet->type() );
+    doc->frameChanged( frame );
+}
+
+
+KWFramePartMoveCommand::KWFramePartMoveCommand( const QString &name, FrameIndex _frameIndex,  FrameResizeStruct _frameMove ) :
+    KNamedCommand(name),
+    m_indexFrame(_frameIndex),
+    m_frameMove(_frameMove)
+{
+}
+
+void KWFramePartMoveCommand::execute()
+{
+    KWFrameSet *frameSet = m_indexFrame.m_pFrameSet;
+    Q_ASSERT( frameSet );
+    KWFrame *frame = frameSet->frame(m_indexFrame.m_iFrameIndex);
+    Q_ASSERT( frame );
+    frame->setCoords(m_frameMove.newRect.left(),m_frameMove.newRect.top(),m_frameMove.newRect.right(),m_frameMove.newRect.bottom());
+
+    KWDocument * doc = frameSet->kWordDocument();
+
+    frame->updateRulerHandles();
+    doc->frameChanged( frame );
+}
+
+void KWFramePartMoveCommand::unexecute()
+{
+    KWFrameSet *frameSet =m_indexFrame.m_pFrameSet;
+    KWFrame *frame=frameSet->frame(m_indexFrame.m_iFrameIndex);
+    frame->setCoords(m_frameMove.oldRect.left(),m_frameMove.oldRect.top(),m_frameMove.oldRect.right(),m_frameMove.oldRect.bottom());
+
+    KWDocument * doc = frameSet->kWordDocument();
+    frame->updateRulerHandles();
+
+    //update frames
+    doc->frameChanged( frame );
+}
+
+bool KWFramePartMoveCommand::frameMoved()
+{
+    return  (m_frameMove.oldRect!=m_frameMove.newRect);
+}
+
+KWFramePartInternalCommand::KWFramePartInternalCommand( const QString &name, KWPartFrameSet *part ) :
+    KNamedCommand(name),
+    m_part(part)
+{
+    m_url = m_part->getChild()->document()->url();
+}
+
+void KWFramePartInternalCommand::execute()
+{
+    m_part->getChild()->document()->setStoreInternal(true);
+}
+
+void KWFramePartInternalCommand::unexecute()
+{
+    m_part->getChild()->document()->setStoreInternal(false);
+    m_part->getChild()->document()->setURL( m_url );
+}
+
+
+KWFramePartExternalCommand::KWFramePartExternalCommand( const QString &name, KWPartFrameSet *part ) :
+    KNamedCommand(name),
+    m_part(part)
+{
+}
+
+void KWFramePartExternalCommand::execute()
+{
+    m_part->getChild()->document()->setStoreInternal(false);
+}
+
+void KWFramePartExternalCommand::unexecute()
+{
+    m_part->getChild()->document()->setStoreInternal(true);
+}
+
+
+KWFrameMoveCommand::KWFrameMoveCommand( const QString &name,
+                                        const QValueList<FrameIndex> & _frameIndex,
+                                        const QValueList<FrameMoveStruct> & _frameMove  ) :
+    KNamedCommand(name),
+    m_indexFrame(_frameIndex),
+    m_frameMove(_frameMove)
+{
+}
+
+void KWFrameMoveCommand::execute()
+{
+    bool needRelayout = false;
+    KWDocument * doc = 0L;
+    QValueList<FrameMoveStruct>::Iterator moveIt = m_frameMove.begin();
+    QValueList<FrameIndex>::Iterator tmp = m_indexFrame.begin();
+    for( ; tmp != m_indexFrame.end() && moveIt != m_frameMove.end(); ++tmp, ++moveIt )
+    {
+        KWFrameSet *frameSet = (*tmp).m_pFrameSet;
+        doc = frameSet->kWordDocument();
+        KWFrame *frame = frameSet->frame((*tmp).m_iFrameIndex);
+        frame->moveTopLeft( (*moveIt).newPos );
+
+        frame->updateRulerHandles();
+        needRelayout = needRelayout || ( frame->runAround() != KWFrame::RA_NO );
+    }
+    if ( doc )
+    {
+        doc->updateAllFrames();
+        if ( needRelayout )
+            doc->layout();
+
+        doc->updateRulerFrameStartEnd();
+        doc->repaintAllViews();
+    }
+}
+
+void KWFrameMoveCommand::unexecute()
+{
+    bool needRelayout = false;
+    KWDocument * doc = 0L;
+    QValueList<FrameMoveStruct>::Iterator moveIt = m_frameMove.begin();
+    QValueList<FrameIndex>::Iterator tmp = m_indexFrame.begin();
+    for( ; tmp != m_indexFrame.end() && moveIt != m_frameMove.end(); ++tmp, ++moveIt )
+    {
+        KWFrameSet *frameSet = (*tmp).m_pFrameSet;
+        doc = frameSet->kWordDocument();
+        KWFrame *frame = frameSet->frame((*tmp).m_iFrameIndex);
+        frame->moveTopLeft( (*moveIt).oldPos );
+
+        frame->updateRulerHandles();
+        needRelayout = needRelayout || ( frame->runAround() != KWFrame::RA_NO );
+    }
+
+    if ( doc )
+    {
+        doc->updateAllFrames();
+        if ( needRelayout )
+            doc->layout();
+        doc->updateRulerFrameStartEnd();
+        doc->repaintAllViews();
+    }
+}
+
+KWFramePropertiesCommand::KWFramePropertiesCommand( const QString &name, KWFrame *_frameBefore,  KWFrame *_frameAfter ) :
+    KNamedCommand(name),
+    m_frameIndex( _frameAfter ),
+    m_frameBefore(_frameBefore),
+    m_frameAfter(_frameAfter->getCopy())
+{
+}
+
+KWFramePropertiesCommand::~KWFramePropertiesCommand()
+{
+    delete m_frameBefore;
+    delete m_frameAfter;
+}
+
+void KWFramePropertiesCommand::execute()
+{
+    kdDebug(32001) << "KWFrameChangeParamCommand::execute" << endl;
+    KWFrameSet *frameSet = m_frameIndex.m_pFrameSet;
+    Q_ASSERT( frameSet );
+
+    KWFrame *frame = frameSet->frame( m_frameIndex.m_iFrameIndex );
+    Q_ASSERT( frame );
+    frame->copySettings(m_frameAfter);
+    frame->frameStack()->update();
+
+    KWDocument * doc = frameSet->kWordDocument();
+    if(doc)
+    {
+        doc->frameChanged( frame );
+        doc->updateAllFrames();
+        doc->layout();
+        doc->repaintAllViews();
+        doc->updateRulerFrameStartEnd();
+    }
+}
+
+void KWFramePropertiesCommand::unexecute()
+{
+    kdDebug(32001) << "KWFrameChangeParamCommand::unexecute" << endl;
+    KWFrameSet *frameSet = m_frameIndex.m_pFrameSet;
+    Q_ASSERT( frameSet );
+
+    KWFrame *frame = frameSet->frame( m_frameIndex.m_iFrameIndex );
+    Q_ASSERT( frame );
+    frame->copySettings(m_frameBefore);
+    frame->frameStack()->update();
+    KWDocument * doc = frameSet->kWordDocument();
+    if(doc)
+    {
+        doc->frameChanged( frame );
+        doc->updateAllFrames();
+        doc->layout();
+        doc->repaintAllViews();
+        doc->updateRulerFrameStartEnd();
+    }
+}
+
+
+KWFrameSetInlineCommand::KWFrameSetInlineCommand( const QString &name, KWFrameSet *frameset, bool value ) :
+    KNamedCommand(name),
+    m_pFrameSet( frameset ),
+    m_value( value )
+{
+    m_oldValue = m_pFrameSet->isFloating();
+}
+
+void KWFrameSetInlineCommand::setValue( bool value )
+{
+    kdDebug(32001) << "KWFrameSetInlineCommand::execute" << endl;
+    if ( value )
+    {
+        // Make frame(set) floating
+        m_pFrameSet->setFloating();
+        // ## We might want to store a list of anchors in the command, and reuse them
+        // in execute/unexecute. Currently setFixed forgets the anchors and setFloating recreates new ones...
+    }
+    else
+    {
+        // Make frame(set) non-floating
+        m_pFrameSet->setFixed();
+    }
+
+    m_pFrameSet->kWordDocument()->updateAllFrames();
+}
+
+void KWFrameSetInlineCommand::execute()
+{
+    setValue( m_value );
+}
+
+void KWFrameSetInlineCommand::unexecute()
+{
+    setValue( m_oldValue );
+}
+
+KWPageLayoutCommand::KWPageLayoutCommand( const QString &name,KWDocument *_doc,KWPageLayoutStruct &_oldLayout, KWPageLayoutStruct &_newLayout  ) :
+    KNamedCommand(name),
+    m_pDoc(_doc),
+    m_oldLayout(_oldLayout),
+    m_newLayout(_newLayout)
+{
+}
+
+void KWPageLayoutCommand::execute()
+{
+    m_pDoc->setPageLayout( m_newLayout._pgLayout, m_newLayout._cl, m_newLayout._hf );
+}
+
+void KWPageLayoutCommand::unexecute()
+{
+    m_pDoc->setPageLayout( m_oldLayout._pgLayout, m_oldLayout._cl, m_oldLayout._hf);
+}
+
+
+KWDeleteFrameCommand::KWDeleteFrameCommand( const QString &name, KWFrame * frame ):
+    KNamedCommand(name),
+    m_frameIndex( frame ),
+    m_copyFrame( frame->getCopy() )
+{
+}
+
+KWDeleteFrameCommand::KWDeleteFrameCommand( const FrameIndex &frameIndex) :
+    KNamedCommand("")
+{
+    m_frameIndex = frameIndex;
+    m_copyFrame = m_frameIndex.m_pFrameSet->frame(m_frameIndex.m_iFrameIndex)->getCopy();
+}
+
+KWDeleteFrameCommand::~KWDeleteFrameCommand()
+{
+    delete m_copyFrame;
+}
+
+
+void KWDeleteFrameCommand::execute()
+{
+    KWFrameSet *frameSet = m_frameIndex.m_pFrameSet;
+    Q_ASSERT( frameSet );
+
+    KWFrame *frame = frameSet->frame( m_frameIndex.m_iFrameIndex );
+    Q_ASSERT( frame );
+
+kdDebug() << "delete frame " << m_frameIndex.m_iFrameIndex << " of " << frameSet->name() << endl;
+    KWDocument* doc = frameSet->kWordDocument();
+    doc->terminateEditing( frameSet );
+    doc->frameChanged( frame );
+    frameSet->deleteFrame( m_frameIndex.m_iFrameIndex );
+
+/*   KWTextFrameSet * textfs = dynamic_cast<KWTextFrameSet *>(fs);
+     if(textfs) { TODO
+        // if content does not fit; change properties of previous frame to be 'do not show'
+     }
+*/
+
+    doc->refreshDocStructure( frameSet->type() );
+    doc->updateTextFrameSetEdit();
+}
+
+void KWDeleteFrameCommand::unexecute()
+{
+    KWFrameSet *frameSet = m_frameIndex.m_pFrameSet;
+    KWFrame * frame = m_copyFrame->getCopy();
+    frame->setFrameSet( frameSet );
+    frameSet->addFrame( frame );
+
+    KWPartFrameSet * partfs = dynamic_cast<KWPartFrameSet *>( frameSet );
+    if ( partfs )
+        partfs->setDeleted( false );
+
+    KWTextFrameSet * textfs = dynamic_cast<KWTextFrameSet *>( frameSet );
+    if ( textfs )
+        textfs->textObject()->formatMore( 2 );
+    KWDocument* doc = frameSet->kWordDocument();
+    doc->frameChanged( frame );
+    // could have been the last frame on a page, so undeleting it needs to recreate the page
+    doc->recalcFrames( frame->pageNumber() );
+    doc->refreshDocStructure(frameSet->type());
+    doc->updateRulerFrameStartEnd();
+}
+
+KWCreateFrameCommand::KWCreateFrameCommand( const QString &name, KWFrame * frame ) :
+    KWDeleteFrameCommand( name, frame )
+{}
+
+
+KWUngroupTableCommand::KWUngroupTableCommand( const QString &name, KWTableFrameSet * _table ):
+    KNamedCommand(name),
+    m_pTable(_table)
+{
+    m_ListFrame.clear();
+    for ( KWTableFrameSet::TableIter i(m_pTable); i ; ++i ) {
+        m_ListFrame.append( i.current() );
+    }
+}
+
+void KWUngroupTableCommand::execute()
+{
+    KWDocument * doc = m_pTable->kWordDocument();
+    for ( KWTableFrameSet::TableIter i(m_pTable) ; i ; ++i ) {
+        i->setGroupManager( 0L );
+        doc->addFrameSet( i.current() );
+    }
+    m_pTable->ungroup();
+    doc->removeFrameSet(m_pTable);
+
+    //when you ungroup a table
+    // you must remove table item in docstruct
+    // create items in text item in docstruct
+
+    int refresh=0;
+    refresh |=Tables;
+    refresh |=TextFrames;
+    doc->refreshDocStructure(refresh);
+
+    doc->updateAllFrames();
+    doc->repaintAllViews();
+}
+
+void KWUngroupTableCommand::unexecute()
+{
+    Q_ASSERT(m_pTable);
+    m_pTable->group();
+    KWDocument * doc = m_pTable->kWordDocument();
+    KWFrameSet *tmp;
+    for ( tmp=m_ListFrame.first(); tmp != 0; tmp=m_ListFrame.next() )
+    {
+        tmp->setGroupManager(m_pTable);
+        doc->removeFrameSet(tmp);
+        KWTableFrameSet::Cell *cell=static_cast<KWTableFrameSet::Cell *>(tmp);
+        Q_ASSERT(cell);
+        m_pTable->addCell( cell );
+    }
+    doc->addFrameSet(m_pTable);
+
+    int refresh=0;
+    refresh |=Tables;
+    refresh |=TextFrames;
+    doc->refreshDocStructure(refresh);
+
+
+    doc->updateAllFrames();
+    doc->repaintAllViews();
+}
+
+
+KWDeleteTableCommand::KWDeleteTableCommand( const QString &name, KWTableFrameSet * _table ):
+    KNamedCommand(name),
+    m_pTable(_table)
+{
+    Q_ASSERT(m_pTable);
+}
+
+void KWDeleteTableCommand::execute()
+{
+    kdDebug(32001) << "KWDeleteTableCommand::execute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    doc->removeFrameSet(m_pTable);
+    m_pTable->setVisible( false );
+    doc->refreshDocStructure((int)Tables);
+    doc->updateAllFrames();
+    m_pTable->updateFrames(); // not in the doc list anymore, so the above call didn't do it!
+    doc->layout();
+    doc->repaintAllViews();
+    doc->updateRulerFrameStartEnd();
+
+}
+
+void KWDeleteTableCommand::unexecute()
+{
+    kdDebug(32001) << "KWDeleteTableCommand::unexecute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    m_pTable->setVisible( true );
+    doc->addFrameSet(m_pTable);
+    doc->refreshDocStructure((int)Tables);
+    doc->updateAllFrames();
+    doc->layout();
+    doc->repaintAllViews();
+    doc->updateRulerFrameStartEnd();
+}
+
+
+KWInsertColumnCommand::KWInsertColumnCommand( const QString &name, KWTableFrameSet * _table, int _col, double _maxRight ):
+    KNamedCommand(name),
+    m_pTable(_table),
+    m_rc(new RemovedColumn()),
+    m_colPos(_col),
+    m_maxRight(_maxRight),
+    m_oldWidth(0)
+{
+    Q_ASSERT(m_pTable);
+}
+
+KWInsertColumnCommand::~KWInsertColumnCommand()
+{
+    delete m_rc;
+}
+
+void KWInsertColumnCommand::execute()
+{
+    kdDebug(32001) << "KWInsertColumnCommand::execute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    // a insert column = KWTableFrameSet::m_sDefaultColWidth, see kwtableframeset.cc
+    if (m_pTable->boundingRect().right() + KWTableFrameSet::m_sDefaultColWidth >= static_cast<int>(m_maxRight))
+    {   // must create space (resize the table)
+        m_oldWidth = m_pTable->boundingRect().width();
+        // here we calculate the new table size for a table that would take the
+        // entire width of the page, which what the user wants 99% of the time.
+        double newTableWidth =m_maxRight - m_pTable->boundingRect().left();
+        double newColSize = newTableWidth / (m_pTable->getColumns()+1);
+        double resizeTableWidth = m_maxRight - m_pTable->boundingRect().left();
+        m_pTable->resizeWidth(resizeTableWidth - newColSize);
+        m_pTable->insertNewColumn(m_colPos, newColSize);
+    }
+    else
+    {   // simply insert the column without asking for a specific size :
+        m_pTable->insertNewColumn(m_colPos);
+    }
+    Q_ASSERT(m_pTable->boundingRect().right() <= m_maxRight);
+    doc->updateAllFrames();
+    doc->layout();
+    doc->repaintAllViews();
+}
+
+void KWInsertColumnCommand::unexecute()
+{
+    kdDebug(32001) << "KWInsertColumnCommand::unexecute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    doc->terminateEditing(m_pTable);
+    m_pTable->deleteColumn(m_colPos, *m_rc);
+    // now undo the resize of the table if necessary:
+    if (m_oldWidth) {
+        // yes, the table was resized, let's undo that :
+        m_pTable->resizeWidth(m_oldWidth);
+    }
+    doc->updateAllFrames();
+    doc->layout();
+    doc->repaintAllViews();
+}
+
+
+
+KWInsertRowCommand::KWInsertRowCommand( const QString &name, KWTableFrameSet * _table, int _row ):
+    KNamedCommand(name),
+    m_pTable(_table),
+    m_rr(new RemovedRow()),
+    m_rowPos(_row),
+    m_inserted(false)
+{
+    Q_ASSERT(m_pTable);
+}
+
+KWInsertRowCommand::~KWInsertRowCommand()
+{
+    delete m_rr;
+}
+
+void KWInsertRowCommand::execute()
+{
+    kdDebug(32001) << "KWInsertRowCommand::execute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    if(m_inserted)
+        m_pTable->reInsertRow(*m_rr);
+    else {
+        m_inserted = true;
+        m_pTable->insertNewRow(m_rowPos);  //only happens the first time
+    }
+    doc->updateAllFrames();
+    doc->layout();
+    doc->repaintAllViews();
+}
+
+void KWInsertRowCommand::unexecute()
+{
+    kdDebug(32001) << "KWInsertRowCommand::unexecute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+
+    doc->terminateEditing(m_pTable);
+    m_pTable->deleteRow( m_rowPos, *m_rr);
+
+    doc->updateAllFrames();
+    doc->layout();
+}
+
+
+KWRemoveRowCommand::KWRemoveRowCommand( const QString &name, KWTableFrameSet * _table, int _row ):
+    KNamedCommand(name),
+    m_pTable(_table),
+    m_rr(new RemovedRow()),
+    m_rowPos(_row)
+{
+    Q_ASSERT(m_pTable);
+}
+
+KWRemoveRowCommand::~KWRemoveRowCommand()
+{
+    delete m_rr;
+}
+
+void KWRemoveRowCommand::execute()
+{
+    kdDebug(32001) << "KWRemoveRowCommand::execute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    doc->terminateEditing(m_pTable);
+
+    m_pTable->deleteRow( m_rowPos, *m_rr);
+
+    doc->updateAllFrames();
+    doc->layout();
+}
+
+void KWRemoveRowCommand::unexecute()
+{
+    kdDebug(32001) << "KWRemoveRowCommand::unexecute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    m_pTable->reInsertRow(*m_rr);
+    doc->updateAllFrames();
+    doc->layout();
+    doc->repaintAllViews();
+}
+
+KWRemoveColumnCommand::KWRemoveColumnCommand( const QString &name, KWTableFrameSet * _table, int _col ):
+    KNamedCommand(name),
+    m_pTable(_table),
+    m_rc(new RemovedColumn()),
+    m_colPos(_col)
+{
+    Q_ASSERT(m_pTable);
+}
+
+KWRemoveColumnCommand::~KWRemoveColumnCommand()
+{
+    delete m_rc;
+}
+
+void KWRemoveColumnCommand::execute()
+{
+    kdDebug(32001) << "KWRemoveColumnCommand::execute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    doc->terminateEditing(m_pTable);
+
+    m_pTable->deleteColumn( m_colPos, *m_rc);
+    doc->updateAllFrames();
+    doc->layout();
+}
+
+void KWRemoveColumnCommand::unexecute()
+{
+    kdDebug(32001) << "KWRemoveColumnCommand::unexecute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    m_pTable->reInsertColumn(*m_rc);
+    doc->updateAllFrames();
+    doc->layout();
+    doc->repaintAllViews();
+}
+
+
+
+KWSplitCellCommand::KWSplitCellCommand( const QString &name, KWTableFrameSet * _table,unsigned int colBegin,unsigned int rowBegin, unsigned int colEnd,unsigned int rowEnd ):
+    KNamedCommand(name),
+    m_pTable(_table),
+    m_colBegin(colBegin),
+    m_rowBegin(rowBegin),
+    m_colEnd(colEnd),
+    m_rowEnd(rowEnd)
+{
+    Q_ASSERT(m_pTable);
+}
+
+void KWSplitCellCommand::execute()
+{
+    kdDebug(32001) << "KWSplitCellCommand::execute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    doc->terminateEditing(m_pTable);
+    //kdDebug()<<"split Cell m_colBegin :"<<m_colBegin<<" m_colEnd :"<<m_colEnd<<" m_rowBegin :"<<m_rowBegin<<" m_colEnd :"<<m_colEnd<<endl;
+    m_pTable->splitCell(m_rowEnd, m_colEnd,m_colBegin,m_rowBegin,m_ListFrameSet);
+    doc->updateAllFrames();
+    doc->layout();
+}
+
+void KWSplitCellCommand::unexecute()
+{
+    kdDebug(32001) << "KWSplitCellCommand::unexecute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    doc->terminateEditing(m_pTable);
+
+    //kdDebug()<<"Join Cell m_colBegin :"<<m_colBegin<<" m_colEnd :"<<m_colBegin+m_colEnd-1<<" m_rowBegin :"<<m_rowBegin<<" m_rowEnd :"<<m_rowBegin+m_rowEnd-1<<endl;
+
+    if(m_ListFrameSet.isEmpty())
+    {
+        for ( unsigned int i = 0; i < m_pTable->getColumns(); i++ )
+        {
+            for ( unsigned int j = 0; j < m_pTable->getRows(); j++ )
+            {
+                if(j>=m_rowBegin && j<=(m_rowBegin+m_rowEnd-1)
+                   && i>=m_colBegin && i<=(m_colEnd+m_colBegin-1))
+                {
+                    //don't store first cell
+                    if( !(j==m_rowBegin && i==m_colBegin))
+                    {
+                        kdDebug(32001)<<"store cell row :"<<j<<" col :"<<i<<endl;
+                        KWTableFrameSet::Cell *cell=static_cast<KWTableFrameSet::Cell *>(m_pTable->cell( j,i ));
+                        m_ListFrameSet.append(cell);
+                    }
+                }
+
+            }
+        }
+    }
+    KWTableFrameSet::Cell *cell=static_cast<KWTableFrameSet::Cell *>(m_pTable->cell( m_rowBegin,m_colBegin ));
+    m_pTable->joinCells(m_colBegin, m_rowBegin, m_colEnd+m_colBegin-1+cell->columnSpan()-1,
+        m_rowBegin+m_rowEnd-1+cell->rowSpan()-1);
+
+    doc->updateAllFrames();
+    doc->layout();
+}
+
+
+
+KWJoinCellCommand::KWJoinCellCommand( const QString &name, KWTableFrameSet * _table,unsigned int colBegin,unsigned int rowBegin, unsigned int colEnd,unsigned int rowEnd, QPtrList<KWFrameSet> listFrameSet,QPtrList<KWFrame> listCopyFrame):
+    KNamedCommand(name),
+    m_pTable(_table),
+    m_colBegin(colBegin),
+    m_rowBegin(rowBegin),
+    m_colEnd(colEnd),
+    m_rowEnd(rowEnd),
+    m_ListFrameSet(listFrameSet),
+    m_copyFrame(listCopyFrame)
+{
+    Q_ASSERT(m_pTable);
+}
+KWJoinCellCommand::~KWJoinCellCommand()
+{
+    m_copyFrame.setAutoDelete( true );
+}
+
+void KWJoinCellCommand::execute()
+{
+    kdDebug(32001) << "KWJoinCellCommand::execute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    doc->terminateEditing(m_pTable);
+    m_pTable->joinCells(m_colBegin,m_rowBegin,m_colEnd,m_rowEnd);
+    doc->updateAllFrames();
+    doc->layout();
+}
+
+void KWJoinCellCommand::unexecute()
+{
+    kdDebug(32001) << "KWJoinCellCommand::unexecute" << endl;
+    KWDocument * doc = m_pTable->kWordDocument();
+    doc->terminateEditing(m_pTable);
+    m_pTable->splitCell(m_rowEnd-m_rowBegin+1, m_colEnd-m_colBegin+1,m_colBegin,m_rowBegin,m_ListFrameSet,m_copyFrame);
+    doc->updateAllFrames();
+    doc->layout();
+}
+
+
+KWChangeStartingPageCommand::KWChangeStartingPageCommand( const QString &name, KWDocument *_doc, int _oldStartingPage, int _newStartingPage):
+    KNamedCommand(name),
+    m_doc(_doc),
+    oldStartingPage(_oldStartingPage),
+    newStartingPage(_newStartingPage)
+{
+}
+
+void KWChangeStartingPageCommand::execute()
+{
+    m_doc->variableCollection()->variableSetting()->setStartingPageNumber(newStartingPage);
+    m_doc->recalcVariables( VT_PGNUM );
+}
+
+void KWChangeStartingPageCommand::unexecute()
+{
+    m_doc->variableCollection()->variableSetting()->setStartingPageNumber(oldStartingPage);
+    m_doc->recalcVariables( VT_PGNUM );
+}
+
+KWChangeVariableSettingsCommand::KWChangeVariableSettingsCommand( const QString &name, KWDocument *_doc, bool _oldValue, bool _newValue, VariableProperties _type):
+    KNamedCommand(name),
+    m_doc(_doc),
+    type(_type),
+    m_bOldValue(_oldValue),
+    m_bNewValue(_newValue)
+{
+}
+
+void KWChangeVariableSettingsCommand::changeValue( bool b )
+{
+    switch(type)
+    {
+    case VS_DISPLAYLINK:
+        m_doc->variableCollection()->variableSetting()->setDisplayLink(b);
+        m_doc->recalcVariables( VT_LINK );
+        break;
+    case  VS_UNDERLINELINK:
+        m_doc->variableCollection()->variableSetting()->setUnderlineLink(b);
+        m_doc->recalcVariables( VT_LINK );
+        break;
+    case VS_DISPLAYCOMMENT:
+        m_doc->variableCollection()->variableSetting()->setDisplayComment(b);
+        m_doc->recalcVariables( VT_NOTE );
+        break;
+    case VS_DISPLAYFIELDCODE:
+        m_doc->variableCollection()->variableSetting()->setDisplayFieldCode(b);
+        //hack necessary otherwise footnote frameset is not refreshing
+        //and footnote is not resize.
+        m_doc->displayFootNoteFieldCode();
+        m_doc->recalcVariables( VT_ALL );
+        break;
+    }
+}
+
+void KWChangeVariableSettingsCommand::execute()
+{
+    changeValue(m_bNewValue);
+}
+
+void KWChangeVariableSettingsCommand::unexecute()
+{
+    changeValue(m_bOldValue);
+}
+
+KWChangeCustomVariableValue::KWChangeCustomVariableValue( const QString &name, KWDocument *_doc,const QString & _oldValue, const QString & _newValue,KoCustomVariable *var):
+    KNamedCommand(name),
+    m_doc(_doc),
+    newValue(_newValue),
+    oldValue(_oldValue),
+    m_var(var)
+{
+}
+
+KWChangeCustomVariableValue::~KWChangeCustomVariableValue()
+{
+}
+
+void KWChangeCustomVariableValue::execute()
+{
+    Q_ASSERT(m_var);
+    m_var->setValue(newValue);
+    m_doc->recalcVariables( VT_CUSTOM );
+}
+
+void KWChangeCustomVariableValue::unexecute()
+{
+    Q_ASSERT(m_var);
+    m_var->setValue(oldValue);
+    m_doc->recalcVariables( VT_CUSTOM );
+}
+
+KWChangeVariableNoteText::KWChangeVariableNoteText( const QString &name, KWDocument *_doc,
+                        const QString &_oldValue,const QString &_newValue,
+                        KoNoteVariable *var):
+    KNamedCommand(name),
+    m_doc(_doc),
+    newValue(_newValue),
+    oldValue(_oldValue),
+    m_var(var)
+{
+}
+
+KWChangeVariableNoteText::~KWChangeVariableNoteText()
+{
+}
+
+void KWChangeVariableNoteText::execute()
+{
+    Q_ASSERT(m_var);
+    m_var->setNote(newValue);
+}
+
+void KWChangeVariableNoteText::unexecute()
+{
+    Q_ASSERT(m_var);
+    m_var->setNote(oldValue);
+}
+
+// TODO: move to libkotext to remove code duplication with kpresenter
+KWChangeLinkVariable::KWChangeLinkVariable( const QString &name, KWDocument *_doc,const QString & _oldHref, const QString & _newHref, const QString & _oldLink,const QString &_newLink, KoLinkVariable *var):
+    KNamedCommand(name),
+    m_doc(_doc),
+    oldHref(_oldHref),
+    newHref(_newHref),
+    oldLink(_oldLink),
+    newLink(_newLink),
+    m_var(var)
+{
+}
+
+
+void KWChangeLinkVariable::execute()
+{
+    m_var->setLink(newLink,newHref);
+    m_doc->recalcVariables(VT_LINK);
+}
+
+void KWChangeLinkVariable::unexecute()
+{
+    m_var->setLink(oldLink,oldHref);
+    m_doc->recalcVariables(VT_LINK);
+}
+
+KWHideShowHeader::KWHideShowHeader( const QString &name, KWDocument *_doc, bool _newValue):
+    KNamedCommand(name),
+    m_doc(_doc),
+    newValue(_newValue)
+{
+}
+
+
+void KWHideShowHeader::execute()
+{
+    m_doc->setHeaderVisible(newValue );
+    m_doc->updateHeaderButton();
+
+}
+
+void KWHideShowHeader::unexecute()
+{
+    m_doc->setHeaderVisible(!newValue );
+    m_doc->updateHeaderButton();
+}
+
+KWHideShowFooter::KWHideShowFooter( const QString &name, KWDocument *_doc, bool _newValue):
+    KNamedCommand(name),
+    m_doc(_doc),
+    newValue(_newValue)
+{
+}
+
+
+void KWHideShowFooter::execute()
+{
+    m_doc->setFooterVisible( newValue );
+    m_doc->updateFooterButton();
+}
+
+void KWHideShowFooter::unexecute()
+{
+    m_doc->setFooterVisible( !newValue );
+    m_doc->updateFooterButton();
+}
+
+
+KWProtectContentCommand::KWProtectContentCommand( const QString &name, KWTextFrameSet*frameset, bool _protect):
+    KNamedCommand(name),
+    m_pFrameSet(frameset),
+    m_bProtect(_protect)
+{
+}
+
+
+void KWProtectContentCommand::execute()
+{
+    m_pFrameSet->setProtectContent(m_bProtect);
+    m_pFrameSet->kWordDocument()->updateTextFrameSetEdit();
+    m_pFrameSet->kWordDocument()->testAndCloseAllFrameSetProtectedContent();
+    m_pFrameSet->kWordDocument()->updateRulerInProtectContentMode();
+
+}
+
+void KWProtectContentCommand::unexecute()
+{
+    m_pFrameSet->setProtectContent(!m_bProtect);
+    m_pFrameSet->kWordDocument()->updateTextFrameSetEdit();
+    m_pFrameSet->kWordDocument()->testAndCloseAllFrameSetProtectedContent();
+    m_pFrameSet->kWordDocument()->updateRulerInProtectContentMode();
+
+}
+
+KWInsertRemovePageCommand::KWInsertRemovePageCommand( KWDocument *_doc, Command cmd, int pgNum)
+    : KCommand(), m_doc(_doc), m_cmd(cmd), m_pgNum(pgNum)
+{}
+
+KWInsertRemovePageCommand::~KWInsertRemovePageCommand() {
+    QValueListIterator<KCommand*> cmdIter = childCommands.begin();
+    for(;cmdIter != childCommands.end(); ++ cmdIter)
+         delete (*cmdIter);
+}
+
+QString KWInsertRemovePageCommand::name() const
+{
+    return m_cmd == Insert ? i18n("Insert Page") // problem with after/before page
+                  : i18n("Delete Page %1").arg(m_pgNum);
+}
+
+void KWInsertRemovePageCommand::execute() {
+    if ( m_cmd == Insert )
+        doInsert(m_pgNum);
+    else
+        doRemove(m_pgNum);
+}
+
+void KWInsertRemovePageCommand::unexecute() {
+    if ( m_cmd == Insert )
+        // remove the page that was inserted
+        doRemove(m_pgNum+1);
+    else
+        // Re-insert the page that was deleted
+        doInsert(m_pgNum-1);
+}
+
+void KWInsertRemovePageCommand::doRemove(int pageNumber) {
+    bool firstRun = childCommands.count() == 0;
+    if(firstRun) {
+        QValueVector<FrameIndex> indexes;
+        QPtrList<KWFrame> frames = m_doc->framesInPage(pageNumber, false);
+        QPtrListIterator<KWFrame> framesIter(frames);
+        for(; framesIter.current(); ++framesIter)
+            indexes.append(FrameIndex(*framesIter));
+
+        // we sort them to make sure frames are deleted in order and indexes are not going
+        // to get mixed up when there is more then one frame of a frameset on the page
+        std::sort(indexes.begin(), indexes.end(), compareIndex);
+
+        QValueVector<FrameIndex>::iterator iter = indexes.begin();
+        for(; iter != indexes.end(); ++iter)
+            childCommands.append(new KWDeleteFrameCommand(*iter));
+    }
+    QValueListIterator<KCommand*> cmdIter = childCommands.begin();
+    for(;cmdIter != childCommands.end(); ++ cmdIter)
+         (*cmdIter)->execute();
+
+    // next move all frames up that are on higher pagenumbers
+    KWPage* page = m_doc->pageManager()->page(pageNumber);
+    Q_ASSERT(page);
+    if(! page) return; // hack to work around bug #125998
+    const double pageHeight = page->height();
+    const double topOfPage = m_doc->pageManager()->topOfPage(pageNumber);
+    m_doc->pageManager()->removePage( pageNumber );
+
+    if(firstRun && m_doc->lastPage() >= pageNumber) { // only walk frames when there was a page
+                                                      // after the deleted one
+        QValueList<FrameIndex> indexes;
+        QValueList<FrameMoveStruct> moveStructs;
+        QPtrListIterator<KWFrameSet> fss = m_doc->framesetsIterator();
+        for(;fss.current(); ++fss) {
+            KWFrameSet *fs = *fss;
+            if(fs->isMainFrameset()) continue;
+            if(fs->isHeaderOrFooter()) continue;
+            if(fs->isFootEndNote()) continue;
+            if(! fs->isVisible()) continue;
+            QPtrList<KWFrame> frames = fs->frameIterator();
+            QPtrListIterator<KWFrame> framesIter(frames);
+            for(; framesIter.current(); ++framesIter) {
+                KWFrame *frame = *framesIter;
+                if(frame->top() > topOfPage) {
+                    indexes.append(FrameIndex(frame));
+                    KoPoint before = frame->topLeft();
+                    frame->moveBy(0, -pageHeight);
+                    moveStructs.append(FrameMoveStruct(before, frame->topLeft()));
+                }
+            }
+        }
+        KCommand *cmd = new KWFrameMoveCommand("", indexes, moveStructs);
+        childCommands.append(cmd);
+    }
+    m_doc->afterRemovePages();
+}
+
+bool KWInsertRemovePageCommand::compareIndex(const FrameIndex &index1, const FrameIndex &index2) {
+    if(index1.m_pFrameSet == index2.m_pFrameSet)
+        return index1.m_iFrameIndex >= index2.m_iFrameIndex;
+    return index1.m_pFrameSet >= index2.m_pFrameSet; // I don't care about frameset order,
+                                                     // so just sort on pointers..
+}
+
+void KWInsertRemovePageCommand::doInsert(int pageNumber) {
+    m_doc->pageManager()->insertPage( pageNumber );
+    for(int i=childCommands.count()-1; i > 0; i--) // reverse order
+        childCommands[i]->unexecute();
+    m_doc->afterInsertPage( pageNumber );
+}
+
+FramePaddingStruct::FramePaddingStruct( KWFrame *frame )
+{
+    topPadding = frame->paddingTop();
+    bottomPadding= frame->paddingBottom();
+    leftPadding = frame->paddingLeft();
+    rightPadding= frame->paddingRight();
+}
+
+FramePaddingStruct::FramePaddingStruct( double _left, double _top, double _right, double _bottom ):
+    topPadding(_top),
+    bottomPadding(_bottom),
+    leftPadding(_left),
+    rightPadding(_right)
+{
+}
+
+
+KWFrameChangeFramePaddingCommand::KWFrameChangeFramePaddingCommand( const QString &name, FrameIndex _frameIndex, FramePaddingStruct _framePaddingBegin, FramePaddingStruct _framePaddingEnd ) :
+    KNamedCommand(name),
+    m_indexFrame(_frameIndex),
+    m_framePaddingBegin(_framePaddingBegin),
+    m_framePaddingEnd(_framePaddingEnd)
+{
+}
+
+void KWFrameChangeFramePaddingCommand::execute()
+{
+    KWFrameSet *frameSet = m_indexFrame.m_pFrameSet;
+    Q_ASSERT( frameSet );
+    KWFrame *frame = frameSet->frame(m_indexFrame.m_iFrameIndex);
+    Q_ASSERT( frame );
+    frame->setFramePadding( m_framePaddingEnd.leftPadding,m_framePaddingEnd.topPadding , m_framePaddingEnd.rightPadding, m_framePaddingEnd.bottomPadding);
+    frameSet->kWordDocument()->frameChanged( frame );
+}
+
+void KWFrameChangeFramePaddingCommand::unexecute()
+{
+    KWFrameSet *frameSet = m_indexFrame.m_pFrameSet;
+    Q_ASSERT( frameSet );
+    KWFrame *frame = frameSet->frame(m_indexFrame.m_iFrameIndex);
+    Q_ASSERT( frame );
+    frame->setFramePadding( m_framePaddingBegin.leftPadding,m_framePaddingBegin.topPadding , m_framePaddingBegin.rightPadding, m_framePaddingBegin.bottomPadding);
+    frameSet->kWordDocument()->frameChanged( frame );
+}
+
+KWChangeFootEndNoteSettingsCommand::KWChangeFootEndNoteSettingsCommand( const QString &name, KoParagCounter _oldCounter, KoParagCounter _newCounter ,bool _footNote ,KWDocument *_doc):
+    KNamedCommand(name),
+    m_oldCounter(_oldCounter),
+    m_newCounter(_newCounter),
+    m_footNote( _footNote ),
+    m_doc(_doc)
+{
+}
+
+void KWChangeFootEndNoteSettingsCommand::execute()
+{
+    changeCounter( m_newCounter);
+}
+
+void KWChangeFootEndNoteSettingsCommand::unexecute()
+{
+    changeCounter( m_oldCounter);
+}
+
+void KWChangeFootEndNoteSettingsCommand::changeCounter( KoParagCounter counter)
+{
+    if (m_footNote )
+    {
+        static_cast<KWVariableSettings*>(m_doc->variableCollection()->variableSetting())->changeFootNoteCounter(counter );
+    }
+    else
+    {
+        static_cast<KWVariableSettings*>(m_doc->variableCollection()->variableSetting())->changeEndNoteCounter(counter );
+    }
+    m_doc->changeFootNoteConfig();
+}
+
+
+KWChangeTabStopValueCommand::KWChangeTabStopValueCommand( const QString &name, double _oldValue, double _newValue, KWDocument *_doc):
+    KNamedCommand(name),
+    m_doc( _doc ),
+    m_oldValue(_oldValue),
+    m_newValue(_newValue)
+{
+}
+
+void KWChangeTabStopValueCommand::execute()
+{
+    m_doc->setTabStopValue ( m_newValue );
+}
+
+void KWChangeTabStopValueCommand::unexecute()
+{
+    m_doc->setTabStopValue ( m_oldValue );
+}
+
+
+
+FootNoteParameter::FootNoteParameter( KWFootNoteVariable *_var )
+{
+    noteType = _var->noteType();
+    numberingType = _var->numberingType();
+    manualString = _var->manualString();
+}
+
+FootNoteParameter::FootNoteParameter( NoteType _noteType, KWFootNoteVariable::Numbering _numberingType, const QString &_manualString)
+{
+    noteType= _noteType;
+    numberingType = _numberingType;
+    manualString = _manualString;
+}
+
+KWChangeFootNoteParametersCommand::KWChangeFootNoteParametersCommand( const QString &name, KWFootNoteVariable * _var, FootNoteParameter _oldParameter, FootNoteParameter _newParameter, KWDocument *_doc):
+    KNamedCommand(name),
+    m_doc( _doc ),
+    m_var( _var ),
+    m_oldParameter( _oldParameter ),
+    m_newParameter( _newParameter)
+{
+}
+
+void KWChangeFootNoteParametersCommand::execute()
+{
+    changeVariableParameter( m_newParameter );
+}
+
+void KWChangeFootNoteParametersCommand::unexecute()
+{
+    changeVariableParameter( m_oldParameter );
+}
+
+void KWChangeFootNoteParametersCommand::changeVariableParameter( FootNoteParameter _param )
+{
+    m_var->setNoteType( _param.noteType );
+    m_var->setNumberingType( _param.numberingType );
+    m_var->setManualString( _param.manualString );
+    m_var->setNumDisplay( -1 ); // force renumberFootNotes to recalc
+    if (  m_var->numberingType()== KWFootNoteVariable::Manual)
+    {
+        m_var->resize();
+        m_var->paragraph()->invalidate(0);
+        m_var->paragraph()->setChanged( true );
+    }
+
+    KWTextFrameSet * frameset = dynamic_cast<KWTextFrameSet *>( m_doc->frameSet( 0 ));
+    Q_ASSERT( frameset );
+    if ( frameset)
+        frameset->renumberFootNotes();
+
+    // Re-layout the footnote/endnote frame
+    KWFrame* footNoteFrame = m_var->frameSet()->frame( 0 );
+    int framePage = footNoteFrame->pageNumber();
+    m_doc->recalcFrames( framePage, -1 );
+
+    // Repaint
+    m_doc->delayedRepaintAllViews();
+}
+
+
+KWChangeFootNoteLineSeparatorParametersCommand::KWChangeFootNoteLineSeparatorParametersCommand( const QString &name, SeparatorLinePos _oldValuePos, SeparatorLinePos _newValuePos, int _oldLength, int _newLength, double _oldWidth, double _newWidth, SeparatorLineLineType _oldLineType, SeparatorLineLineType _newLineType, KWDocument *_doc):
+    KNamedCommand(name),
+    m_doc( _doc ),
+    m_oldValuePos(_oldValuePos),
+    m_newValuePos(_newValuePos),
+    m_oldLength(_oldLength),
+    m_newLength(_newLength),
+    m_oldWidth(_oldWidth),
+    m_newWidth(_newWidth),
+    m_oldLineType(_oldLineType),
+    m_newLineType(_newLineType)
+
+{
+}
+
+void KWChangeFootNoteLineSeparatorParametersCommand::execute()
+{
+    changeLineSeparatorParameter( m_newValuePos, m_newLength, m_newWidth,m_newLineType );
+}
+
+void KWChangeFootNoteLineSeparatorParametersCommand::unexecute()
+{
+    changeLineSeparatorParameter( m_oldValuePos, m_oldLength, m_oldWidth, m_oldLineType);
+}
+
+void KWChangeFootNoteLineSeparatorParametersCommand::changeLineSeparatorParameter( SeparatorLinePos _pos, int _length, double _width, SeparatorLineLineType _type)
+{
+    m_doc->setFootNoteSeparatorLinePosition( _pos );
+    m_doc->setFootNoteSeparatorLineLength( _length);
+    m_doc->setFootNoteSeparatorLineWidth(_width );
+    m_doc->setFootNoteSeparatorLineType( _type );
+    m_doc->repaintAllViews();
+}
+
+
+KWRenameBookmarkCommand::KWRenameBookmarkCommand( const QString &name, const QString & _oldname, const QString & _newName, KWDocument *_doc):
+    KNamedCommand(name),
+    m_doc( _doc ),
+    m_oldName( _oldname),
+    m_newName( _newName)
+{
+}
+
+void KWRenameBookmarkCommand::execute()
+{
+    m_doc->renameBookmark( m_oldName, m_newName);
+}
+
+void KWRenameBookmarkCommand::unexecute()
+{
+    m_doc->renameBookmark( m_newName, m_oldName);
+}
+
+KWResizeColumnCommand::KWResizeColumnCommand( KWTableFrameSet *table, int col, double oldSize, double newSize ):
+    KNamedCommand( i18n("Resize Column") ),
+    m_table( table ),
+    m_oldSize( oldSize ),
+    m_newSize( newSize ),
+    m_col( col )
+{
+}
+
+void KWResizeColumnCommand::execute()
+{
+  m_table->resizeColumn(m_col, m_newSize);
+  m_table->kWordDocument()->layout();
+  m_table->kWordDocument()->repaintAllViews();
+}
+
+void KWResizeColumnCommand::unexecute()
+{
+  m_table->resizeColumn(m_col, m_oldSize);
+  m_table->kWordDocument()->layout();
+  m_table->kWordDocument()->repaintAllViews();
+}
+
+KWResizeRowCommand::KWResizeRowCommand( KWTableFrameSet *table, int row, double oldSize, double newSize ):
+    KNamedCommand( i18n("Resize Row") ),
+    m_table( table ),
+    m_oldSize( oldSize ),
+    m_newSize( newSize ),
+    m_row( row )
+{
+}
+
+void KWResizeRowCommand::execute()
+{
+  m_table->resizeRow( m_row, m_newSize );
+  m_table->kWordDocument()->repaintAllViews();
+}
+
+void KWResizeRowCommand::unexecute()
+{
+  m_table->resizeRow( m_row, m_oldSize );
+  m_table->kWordDocument()->repaintAllViews();
+}