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, 616 insertions, 0 deletions

diff --git a/lib/kopalette/kopalettemanager.cc b/lib/kopalette/kopalettemanager.cc
new file mode 100644
index 00000000..e028a7ae
--- /dev/null
+++ b/lib/kopalette/kopalettemanager.cc
@@ -0,0 +1,616 @@
+/*
+ *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
+ *
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License version 2, as published by the Free Software Foundation.
+
+   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 <qapplication.h>
+#include <qdockarea.h>
+#include <qdockwindow.h>
+#include <qdict.h>
+#include <qwidget.h>
+#include <qobject.h>
+#include <qevent.h>
+
+#include <kparts/event.h>
+#include <kapplication.h>
+#include <kpopupmenu.h>
+#include <kaction.h>
+#include <kactionclasses.h>
+#include <kdebug.h>
+#include <klocale.h>
+#include <kglobal.h>
+
+#include <KoView.h>
+#include <KoMainWindow.h>
+
+#include <kopalette.h>
+#include <kotabpalette.h>
+#include <kotoolboxpalette.h>
+
+#include <kopalettemanager.h>
+
+
+KoPaletteManager::KoPaletteManager(KoView * view, KActionCollection *ac, const char * name)
+    : QObject(view, name)
+{
+
+    m_view = view;
+    m_view->installEventFilter(this);
+    m_actionCollection = ac;
+
+    m_actions = new QDict<KToggleAction>();
+    m_widgets = new QDict<QWidget>();
+    m_palettes = new QDict<KoPalette>();
+    m_palettes->setAutoDelete(true);
+    m_defaultMapping = new QMap<QString, QString>();
+    m_currentMapping = new QMap<QString, QString>();
+    m_fixedWidth = 0;
+    m_setFixedWidth = false;
+    
+    m_widgetNames = new QStringList();
+
+    m_mapper = new QSignalMapper(this);
+    connect(m_mapper, SIGNAL(mapped(int)), this, SLOT(slotTogglePalette(int)));
+    m_viewActionMenu = new KActionMenu(i18n("Palettes"), m_actionCollection, "view_palette_action_menu");
+
+    KConfig * cfg = KGlobal::config();
+    cfg->setGroup("palettes");
+
+    bool palettesShown = cfg->readBoolEntry("palettesshown", true);
+    KToggleAction * m_toggleShowHidePalettes;
+
+    if ( palettesShown) {
+        m_toggleShowHidePalettes = new KToggleAction(i18n("Hide All Palette Windows"),
+                                    "CTRL+SHIFT+H", this,
+                                    SLOT(slotToggleAllPalettes()),
+                                    m_actionCollection, "toggleAllPaletteWindows");
+
+        m_toggleShowHidePalettes->setCheckedState(i18n("Show Palette Windows Again"));
+    }
+    else {
+        m_toggleShowHidePalettes = new KToggleAction(i18n("Show Palette Windows Again"),
+                                    "CTRL+SHIFT+H", this,
+                                    SLOT(slotToggleAllPalettes()),
+                                    m_actionCollection, "toggleAllPaletteWindows");
+
+        m_toggleShowHidePalettes->setCheckedState(i18n("Hide All Palette Windows"));
+    }
+    m_viewActionMenu->insert(m_toggleShowHidePalettes);
+
+    // Recreate the palettes in the saved order
+    QStringList paletteList = QStringList::split(",", cfg->readEntry("palettes"));
+    QStringList::iterator it;
+    for (it = paletteList.begin(); it != paletteList.end(); ++it) {
+        if (cfg->hasGroup("palette-" + (*it))) {
+
+            cfg->setGroup("palette-" + (*it));
+
+            enumKoPaletteStyle style = (enumKoPaletteStyle)cfg->readNumEntry("style", 0);
+            QString caption = cfg->readEntry("caption", "");
+
+            createPalette((*it), caption, style);
+        }
+    }
+
+/*
+    KAction * a = new KAction(i18n("Restore Palettes"),
+                  0, this,
+                  SLOT(slotReset()),
+                  this, "restorePalettes");
+    m_viewActionMenu->insert(a);
+*/
+    m_viewActionMenu->popupMenu()->insertSeparator();
+}
+
+
+KoPaletteManager::~KoPaletteManager()
+{
+    save();
+
+    delete m_viewActionMenu;
+    delete m_widgetNames;
+    delete m_widgets;
+    delete m_palettes;
+    delete m_actions;
+    delete m_mapper;
+    delete m_defaultMapping;
+    delete m_currentMapping;
+}
+
+void KoPaletteManager::addWidget(QWidget * widget,
+                                 const QString & name,
+                                 const QString & paletteName,
+                                 int position,
+                                 enumKoPaletteStyle style,
+                                 bool shown)
+{
+
+    if (!widget) return;
+
+    QString pname = paletteName;
+
+    QWidget * w = m_widgets->find(name);
+    if (w != 0 )
+    {
+        removeWidget(name);
+    }
+
+    bool visible = true;
+
+    KConfig * cfg = KGlobal::config();
+    if (cfg->hasGroup("palettetab-" + name)) {
+        cfg->setGroup("palettetab-" + name);
+
+        pname = cfg->readEntry("docker");
+        visible = cfg->readBoolEntry("visible");
+    }
+
+    KoPalette * palette = m_palettes->find(pname);
+
+    if (palette == 0) {
+        palette = createPalette(pname, widget->caption(), style);
+        m_defaultPaletteOrder.append(pname+ "," + QString::number(style));
+    }
+
+    KToggleAction * a;
+    a = new KToggleAction(i18n("Show %1").arg(widget->caption()), 0, m_mapper, SLOT(map()), m_actionCollection);
+    a->setCheckedState(i18n("Hide %1").arg(widget->caption()));
+
+    m_mapper->setMapping(a, m_widgetNames->count()); // This is the position at which we'll insert the action
+    m_actions->insert( name, a );
+    m_viewActionMenu->insert(a);
+
+    palette->plug(widget, name, position);
+
+    m_widgets->insert(name, widget);
+
+    // Default mappings ready for restoring
+    m_defaultMapping->insert(name, pname);
+    m_defaultWidgetOrder.append(name);
+
+    // Find out the hidden state
+    if(m_widgetNames->contains(name))
+    {
+
+        // The widget has already been added (and removed) during this session
+        if(m_hiddenWidgets.contains(name))
+            palette->hidePage( widget );
+        else
+        {
+            a->setChecked(true);
+            palette->showPage( widget );
+        }
+    }
+    else
+    {
+        cfg->setGroup("palettes");
+        if( cfg->readBoolEntry("palettesshown", shown))
+        {
+            if (visible)
+            {
+                a->setChecked(true);
+                palette->showPage( widget );
+            }
+            else
+                palette->hidePage( widget );
+        }
+        else
+        {
+            if (visible)
+                m_hiddenWidgets.push(name);
+            palette->hidePage( widget );
+        }
+    }
+
+    // Fill the current mappings
+    m_widgetNames->append(name);
+    m_currentMapping->insert(name, pname);
+}
+
+
+void KoPaletteManager::slotReset()
+{
+    // Clear all old palettes
+    m_palettes->setAutoDelete( true );
+    m_palettes->clear();
+
+    m_widgetNames->clear();
+
+    // Recreate the palettewindows in the saved order
+    QStringList::iterator it;
+    for (it = m_defaultPaletteOrder.begin(); it != m_defaultPaletteOrder.end(); ++it) {
+        QString s = *it;
+        QString pname = s.section( ",", 0, 0 );;
+        enumKoPaletteStyle style = (enumKoPaletteStyle)s.section(",", 1,1).toInt();
+        createPalette(pname, "", style);
+    }
+
+    // Place all existing (that we didn't throw away!) tabs in the right palette and in the right order
+    for (it = m_defaultWidgetOrder.begin(); it != m_defaultWidgetOrder.end(); ++it) {
+
+        QString widgetName = *it;
+        QWidget * w = m_widgets->find(widgetName);
+
+        if (!w) {
+            continue;
+        }
+        QString paletteName = *m_defaultMapping->find(widgetName);
+        KoPalette * p = m_palettes->find(paletteName);
+
+        if (p == 0) {
+            // Funny -- we should have a consistent set of palettes without holes!
+            createPalette(paletteName, "", PALETTE_DOCKER);
+        }
+
+        p->plug(w, widgetName, -1); // XXX: This is not good: we should add it in the same place as originally placed
+        m_widgetNames->append(widgetName);
+        m_currentMapping->insert(widgetName, paletteName);
+    }
+}
+
+void KoPaletteManager::slotResetFont()
+{
+    QDictIterator<KoPalette> it(*m_palettes);
+    for (; it.current(); ++it) {
+        it.current()->resetFont();
+    }
+
+}
+
+QWidget * KoPaletteManager::widget(const QString & name)
+{
+    return m_widgets->find(name);
+}
+
+void KoPaletteManager::showWidget(const QString & name)
+{
+    QWidget * w = m_widgets->find(name);
+    if (!w) return;
+
+    QString pname = *m_currentMapping->find(name);
+    if (pname.isNull()) return;
+
+    KoPalette * p = m_palettes->find(pname);
+    p->showPage(w);
+
+    KToggleAction * a = m_actions->find(name);
+    a->setChecked(true);
+}
+
+void KoPaletteManager::hideWidget(const QString & name)
+{
+    QWidget * w = m_widgets->find(name);
+    if (!w) return;
+
+    QString pname = *m_currentMapping->find(name);
+    if (pname.isNull()) return;
+
+    KoPalette * p = m_palettes->find(pname);
+    p->hidePage(w);
+
+    KToggleAction * a = m_actions->find(name);
+    a->setChecked(false);
+}
+
+void KoPaletteManager::removeWidget(const QString & name)
+{
+    QString palette = *(m_currentMapping->find(name));
+    if (palette.isNull()) return;
+
+    QWidget * w = m_widgets->find(name);
+    if (!w) return;
+
+    KoPalette * p = m_palettes->find(palette);
+    if (!p) return;
+
+    p->showPage(w);
+    p->unplug(w);
+    m_widgets->remove(name);
+    m_currentMapping->remove(name);
+
+    KAction * a = m_actions->take(name);
+    m_viewActionMenu->remove(a);
+    m_actionCollection->remove(a);
+}
+
+KoPalette * KoPaletteManager::createPalette(const QString & name, const QString & caption, enumKoPaletteStyle style)
+{
+    Q_ASSERT(m_view);
+    KoPalette * palette = 0;
+
+    
+    palette = m_palettes->find(name);
+    if (palette) return palette;
+
+
+    switch (style) {
+        case (PALETTE_DOCKER):
+            palette = new KoTabPalette(m_view, name.latin1());
+            break;
+        case (PALETTE_TOOLBOX):
+            palette = new KoToolBoxPalette(m_view, name.latin1());
+            break;
+        default:
+            // This is a custom palette that we cannot create
+            return 0;
+    };
+
+    if(!palette) return 0;
+
+    if (m_setFixedWidth)
+        palette->setFixedWidth(m_fixedWidth);
+    
+    palette->setCaption(caption);
+    m_palettes->insert(name, palette);
+    placePalette(name);
+
+    return palette;
+}
+
+void KoPaletteManager::placePalette(const QString & name, Qt::Dock location)
+{
+    Q_ASSERT(!name.isNull());
+    KoPalette * palette = m_palettes->find(name);
+
+    if (!palette) return;
+
+    //XXX:  Check whether this name occurs in the config list, retrieve the location, set the location
+    KConfig * cfg = KGlobal::config();
+
+    if (cfg->hasGroup("palette-" + name)) {
+        cfg->setGroup("palette-" + name);
+        QString dockarea = cfg->readEntry("dockarea", "right");
+        QString caption = cfg->readEntry("caption", "");
+        int height = cfg->readNumEntry("height", 120);
+        int place = cfg->readNumEntry("place", 0);
+        int width = cfg->readNumEntry("width", 200);
+        int x = cfg->readNumEntry("x", 0);
+        int y = cfg->readNumEntry("y", 0);
+        int offset = cfg->readNumEntry("offset", 0);
+        palette->setGeometry(x, y, width, height);
+        palette->setOffset(offset);
+        if (dockarea == "left" && place == 0) {
+            location = Qt::DockLeft;
+        }
+        else if (dockarea == "right" && place == 0) {
+            location = Qt::DockRight;
+        }
+        else {
+            location = DockTornOff;
+        }
+    }
+
+    cfg->setGroup("");
+    m_dockability = (enumKoDockability) cfg->readNumEntry("palettesdockability");
+
+    // Top and bottom will never accept docks
+    m_view->mainWindow()->topDock()->setAcceptDockWindow(palette, false);
+    m_view->mainWindow()->bottomDock()->setAcceptDockWindow(palette, false);
+
+    // Left and right may accept docks. The height of the screen is important
+    int h = qApp->desktop()->height();
+    switch (m_dockability) {
+        case (DOCK_ENABLED):
+            m_view->mainWindow()->leftDock()->setAcceptDockWindow(palette, true);
+            m_view->mainWindow()->rightDock()->setAcceptDockWindow(palette, true);
+            m_view->mainWindow()->addDockWindow(palette, location);
+            break;
+        case (DOCK_DISABLED):
+            m_view->mainWindow()->leftDock()->setAcceptDockWindow(palette, false);
+            m_view->mainWindow()->rightDock()->setAcceptDockWindow(palette, false);
+            m_view->mainWindow()->addDockWindow(palette, Qt::DockTornOff);
+            break;
+        case (DOCK_SMART):
+            if (h > 768) {
+                m_view->mainWindow()->leftDock()->setAcceptDockWindow(palette, true);
+                m_view->mainWindow()->rightDock()->setAcceptDockWindow(palette, true);
+                m_view->mainWindow()->addDockWindow(palette, location);
+            }
+            else {
+                m_view->mainWindow()->leftDock()->setAcceptDockWindow(palette, false);
+                m_view->mainWindow()->rightDock()->setAcceptDockWindow(palette, false);
+                m_view->mainWindow()->addDockWindow(palette, Qt::DockTornOff);
+           }
+            break;
+    };
+    m_view->mainWindow()->lineUpDockWindows();
+}
+
+void KoPaletteManager::addPalette(KoPalette * palette, const QString & name, Qt::Dock location)
+{
+    Q_ASSERT(palette);
+    Q_ASSERT(!name.isNull());
+
+    m_palettes->insert(name, palette);
+    placePalette(name, location);
+}
+
+void KoPaletteManager::slotTogglePalette(int paletteIndex)
+{
+    // Toggle the right palette
+    QString name = *m_widgetNames->at(paletteIndex);
+    QWidget * w = m_widgets->find(name);
+    QString pname = *m_currentMapping->find(name);
+    KoPalette * p = m_palettes->find(pname);
+    p->togglePageHidden( w );
+
+    m_hiddenWidgets.clear();
+}
+
+void KoPaletteManager::slotToggleAllPalettes()
+{
+    if( ! m_hiddenWidgets.isEmpty())
+    {
+        // Restore previous visibility state
+        while(!m_hiddenWidgets.isEmpty())
+        {
+            QString name = m_hiddenWidgets.pop();
+            QWidget *w = m_widgets->find(name);
+            KToggleAction * a = m_actions->find(name);
+            a->setChecked(true);
+
+            QString pname = *m_currentMapping->find(name);
+            KoPalette * p = m_palettes->find(pname);
+            p->showPage(w);
+        }
+    }
+    else
+    {
+        // Save hidden state and hide all palettes
+        m_hiddenWidgets.clear();
+        QDictIterator<QWidget> it(*m_widgets);
+        for (; it.current(); ++it)
+        {
+            KToggleAction * a = m_actions->find(it.currentKey());
+            if(a->isChecked())
+            {
+                a->setChecked(false);
+                m_hiddenWidgets.push(it.currentKey());
+
+                QString pname = *m_currentMapping->find(it.currentKey());
+                KoPalette * p = m_palettes->find(pname);
+                p->hidePage(it.current());
+            }
+        }
+    }
+}
+
+void KoPaletteManager::showAllPalettes(bool shown)
+{
+    QDictIterator<KoPalette> it(*m_palettes);
+    for (; it.current(); ++it) {
+        it.current()->makeVisible(shown);
+    }
+}
+
+bool KoPaletteManager::eventFilter( QObject *o, QEvent *e )
+{
+    if (o != m_view) return false;
+
+    if(e && e->type() == (QEvent::User + 42)) {
+         KParts::PartActivateEvent * pae = dynamic_cast<KParts::PartActivateEvent *>(e);
+         if(pae && pae->widget() && pae->widget() == m_view) {
+            if (pae->activated()) {
+                showAllPalettes( true );
+            }
+            else {
+                showAllPalettes( false );
+            }
+         }
+    }
+    return false;
+}
+
+
+
+void KoPaletteManager::save()
+{
+    // XXX: Save to the configuration
+    // We save:
+    //   * which tab at which place in which palette
+    //   * which tab is hidden
+    //   * whether a palette is floating or docked
+    //   * dock location of a docked palette
+    //   * float location of a floated palette
+    //   * order in which the palettes are docked.
+
+    if (!m_view) return;
+    if (!m_view->mainWindow()) return;
+
+    KConfig * cfg = KGlobal::config();
+    Q_ASSERT(cfg);
+    cfg->setGroup("");
+
+    QString widgets;
+
+    // Save the list of palettes
+    QDictIterator<KoPalette> itP(*m_palettes);
+
+    QStringList paletteList;
+
+    for (; itP.current(); ++itP) {
+
+        KoPalette * p = itP.current();
+
+        cfg->setGroup("palette-" + itP.currentKey());
+
+        if ( p->area() == m_view->mainWindow()->leftDock() ) {
+            cfg->writeEntry("dockarea", "left");
+        }
+        else {
+            cfg->writeEntry("dockarea", "right");
+        }
+        cfg->writeEntry("place", p->place());
+        cfg->writeEntry("x", p->x());
+        cfg->writeEntry("y", p->y());
+        cfg->writeEntry("height", p->height());
+        cfg->writeEntry("width", p->width());
+        cfg->writeEntry("palettestyle", p->style());
+        cfg->writeEntry("caption", p->caption());
+        cfg->writeEntry("offset", p->offset());
+
+        // XXX: I dare say that it is immediately visible that I never have had
+        //      any formal training in algorithms. BSAR.
+        if (paletteList.isEmpty()) {
+            paletteList.append(itP.currentKey());
+        }
+        else {
+            QStringList::iterator it;
+            bool inserted = false;
+            for (it = paletteList.begin(); it != paletteList.end(); ++it) {
+                KoPalette * p2 = m_palettes->find((*it));
+                if (p2->y() > p->y()) {
+                    paletteList.insert(it, itP.currentKey());
+                    inserted = true;
+                    break;
+                }
+            }
+            if (!inserted) {
+                paletteList.append(itP.currentKey());
+            }
+        }
+    }
+
+    cfg->setGroup("palettes");
+
+    cfg->writeEntry("palettes", paletteList.join(","));
+    bool palettesShown = m_hiddenWidgets.isEmpty();
+    cfg->writeEntry("palettesshown", palettesShown);
+
+    QDictIterator<QWidget> itW(*m_widgets);
+    for (; itW.current(); ++itW) {
+        cfg->setGroup("palettetab-" + itW.currentKey());
+        QString pname = *m_currentMapping->find(itW.currentKey());
+        KoPalette * p = m_palettes->find(pname);
+        QWidget * w = itW.current();
+        cfg->writeEntry("docker", pname);
+
+        if(palettesShown)
+            cfg->writeEntry("visible", !p->isHidden(w));
+        else
+            if(m_hiddenWidgets.contains(itW.currentKey()))
+               cfg->writeEntry("visible", true);
+            else
+                cfg->writeEntry("visible", false);
+    }
+}
+
+void KoPaletteManager::setFixedWidth(int w)
+{
+    m_fixedWidth = w;
+    m_setFixedWidth = true;
+}
+
+#include "kopalettemanager.moc"