summaryrefslogtreecommitdiffstats
path: root/tdeui/kedittoolbar.cpp
diff options
context:
space:
mode:
authorTimothy Pearson <[email protected]>2011-11-06 15:56:40 -0600
committerTimothy Pearson <[email protected]>2011-11-06 15:56:40 -0600
commite16866e072f94410321d70daedbcb855ea878cac (patch)
treeee3f52eabde7da1a0e6ca845fb9c2813cf1558cf /tdeui/kedittoolbar.cpp
parenta58c20c1a7593631a1b50213c805507ebc16adaf (diff)
downloadtdelibs-e16866e072f94410321d70daedbcb855ea878cac.tar.gz
tdelibs-e16866e072f94410321d70daedbcb855ea878cac.zip
Actually move the kde files that were renamed in the last commit
Diffstat (limited to 'tdeui/kedittoolbar.cpp')
-rw-r--r--tdeui/kedittoolbar.cpp1455
1 files changed, 1455 insertions, 0 deletions
diff --git a/tdeui/kedittoolbar.cpp b/tdeui/kedittoolbar.cpp
new file mode 100644
index 000000000..98a1f0537
--- /dev/null
+++ b/tdeui/kedittoolbar.cpp
@@ -0,0 +1,1455 @@
+// -*- mode: c++; c-basic-offset: 2 -*-
+/* This file is part of the KDE libraries
+ Copyright (C) 2000 Kurt Granroth <[email protected]>
+
+ 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 <kedittoolbar.h>
+
+#include <tqdom.h>
+#include <tqlayout.h>
+#include <tqdir.h>
+#include <tqfile.h>
+#include <tqheader.h>
+#include <tqcombobox.h>
+#include <tqdragobject.h>
+#include <tqtoolbutton.h>
+#include <tqlabel.h>
+#include <tqvaluelist.h>
+#include <tqapplication.h>
+#include <tqtextstream.h>
+
+#include <kaction.h>
+#include <kstandarddirs.h>
+#include <klocale.h>
+#include <kicontheme.h>
+#include <kiconloader.h>
+#include <kinstance.h>
+#include <kmessagebox.h>
+#include <kxmlguifactory.h>
+#include <kseparator.h>
+#include <kconfig.h>
+#include <klistview.h>
+#include <kdebug.h>
+#include <kpushbutton.h>
+#include <kprocio.h>
+
+static const char * const lineseparatorstring = I18N_NOOP("--- line separator ---");
+static const char * const separatorstring = I18N_NOOP("--- separator ---");
+
+#define LINESEPARATORSTRING i18n(lineseparatorstring)
+#define SEPARATORSTRING i18n(separatorstring)
+
+static void dump_xml(const TQDomDocument& doc)
+{
+ TQString str;
+ TQTextStream ts(&str, IO_WriteOnly);
+ ts << doc;
+ kdDebug() << str << endl;
+}
+
+typedef TQValueList<TQDomElement> ToolbarList;
+
+namespace
+{
+class XmlData
+{
+public:
+ enum XmlType { Shell = 0, Part, Local, Merged };
+ XmlData()
+ {
+ m_isModified = false;
+ m_actionCollection = 0;
+ }
+
+ TQString m_xmlFile;
+ TQDomDocument m_document;
+ XmlType m_type;
+ bool m_isModified;
+ KActionCollection* m_actionCollection;
+
+ ToolbarList m_barList;
+};
+
+typedef TQValueList<XmlData> XmlDataList;
+
+class ToolbarItem : public TQListViewItem
+{
+public:
+ ToolbarItem(KListView *parent, const TQString& tag = TQString::null, const TQString& name = TQString::null, const TQString& statusText = TQString::null)
+ : TQListViewItem(parent),
+ m_tag(tag),
+ m_name(name),
+ m_statusText(statusText)
+ {
+ }
+
+ ToolbarItem(KListView *parent, TQListViewItem *item, const TQString &tag = TQString::null, const TQString& name = TQString::null, const TQString& statusText = TQString::null)
+ : TQListViewItem(parent, item),
+ m_tag(tag),
+ m_name(name),
+ m_statusText(statusText)
+ {
+ }
+
+ virtual TQString key(int column, bool) const
+ {
+ TQString s = text( column );
+ if ( s == LINESEPARATORSTRING )
+ return "0";
+ if ( s == SEPARATORSTRING )
+ return "1";
+ return "2" + s;
+ }
+
+ void setInternalTag(const TQString &tag) { m_tag = tag; }
+ void setInternalName(const TQString &name) { m_name = name; }
+ void setStatusText(const TQString &text) { m_statusText = text; }
+ TQString internalTag() const { return m_tag; }
+ TQString internalName() const { return m_name; }
+ TQString statusText() const { return m_statusText; }
+private:
+ TQString m_tag;
+ TQString m_name;
+ TQString m_statusText;
+};
+
+#define TOOLBARITEMMIMETYPE "data/x-kde.toolbar.item"
+class ToolbarItemDrag : public TQStoredDrag
+{
+public:
+ ToolbarItemDrag(ToolbarItem *toolbarItem,
+ TQWidget *dragSource = 0, const char *name = 0)
+ : TQStoredDrag( TOOLBARITEMMIMETYPE, dragSource, name )
+ {
+ if (toolbarItem) {
+ TQByteArray data;
+ TQDataStream out(data, IO_WriteOnly);
+ out << toolbarItem->internalTag();
+ out << toolbarItem->internalName();
+ out << toolbarItem->statusText();
+ out << toolbarItem->text(1); // separators need this.
+ setEncodedData(data);
+ }
+ }
+
+ static bool canDecode(TQMimeSource* e)
+ {
+ return e->provides(TOOLBARITEMMIMETYPE);
+ }
+
+ static bool decode( const TQMimeSource* e, ToolbarItem& item )
+ {
+ if (!e)
+ return false;
+
+ TQByteArray data = e->tqencodedData(TOOLBARITEMMIMETYPE);
+ if ( data.isEmpty() )
+ return false;
+
+ TQString internalTag, internalName, statusText, text;
+ TQDataStream in(data, IO_ReadOnly);
+ in >> internalTag;
+ in >> internalName;
+ in >> statusText;
+ in >> text;
+
+ item.setInternalTag( internalTag );
+ item.setInternalName( internalName );
+ item.setStatusText( statusText );
+ item.setText(1, text);
+
+ return true;
+ }
+};
+
+class ToolbarListView : public KListView
+{
+public:
+ ToolbarListView(TQWidget *parent=0, const char *name=0)
+ : KListView(parent, name)
+ {
+ }
+protected:
+ virtual TQDragObject *dragObject()
+ {
+ ToolbarItem *item = dynamic_cast<ToolbarItem*>(selectedItem());
+ if ( item ) {
+ ToolbarItemDrag *obj = new ToolbarItemDrag(item,
+ this, "ToolbarAction drag item");
+ const TQPixmap *pm = item->pixmap(0);
+ if( pm )
+ obj->setPixmap( *pm );
+ return obj;
+ }
+ return 0;
+ }
+
+ virtual bool acceptDrag(TQDropEvent *event) const
+ {
+ return ToolbarItemDrag::canDecode( event );
+ }
+};
+} // namespace
+
+class KEditToolbarWidgetPrivate
+{
+public:
+ /**
+ * @param instance The instance.
+ * @param collection In a non-KParts application, this is the collection passed
+ * to the KEditToolbar constructor.
+ * In a KParts application we let create a KXMLGUIClient create a dummy one,
+ * but it probably isn't used.
+ */
+ KEditToolbarWidgetPrivate(KInstance *instance, KActionCollection* collection)
+ : m_collection( collection )
+ {
+ m_instance = instance;
+ m_isPart = false;
+ m_helpArea = 0L;
+ m_kdialogProcess = 0;
+ }
+ ~KEditToolbarWidgetPrivate()
+ {
+ }
+
+ TQString xmlFile(const TQString& xml_file)
+ {
+ return xml_file.isNull() ? TQString(m_instance->instanceName()) + "ui.rc" :
+ xml_file;
+ }
+
+ /**
+ * Load in the specified XML file and dump the raw xml
+ */
+ TQString loadXMLFile(const TQString& _xml_file)
+ {
+ TQString raw_xml;
+ TQString xml_file = xmlFile(_xml_file);
+ //kdDebug() << "loadXMLFile xml_file=" << xml_file << endl;
+
+ if ( !TQDir::isRelativePath(xml_file) )
+ raw_xml = KXMLGUIFactory::readConfigFile(xml_file);
+ else
+ raw_xml = KXMLGUIFactory::readConfigFile(xml_file, m_instance);
+
+ return raw_xml;
+ }
+
+ /**
+ * Return a list of toolbar elements given a toplevel element
+ */
+ ToolbarList findToolbars(TQDomNode n)
+ {
+ static const TQString &tagToolbar = KGlobal::staticQString( "ToolBar" );
+ static const TQString &attrNoEdit = KGlobal::staticQString( "noEdit" );
+ ToolbarList list;
+
+ for( ; !n.isNull(); n = n.nextSibling() )
+ {
+ TQDomElement elem = n.toElement();
+ if (elem.isNull())
+ continue;
+
+ if (elem.tagName() == tagToolbar && elem.attribute( attrNoEdit ) != "true" )
+ list.append(elem);
+
+ list += findToolbars(elem.firstChild());
+ }
+
+ return list;
+ }
+
+ /**
+ * Return the name of a given toolbar
+ */
+ TQString toolbarName( const XmlData& xmlData, const TQDomElement& it ) const
+ {
+ static const TQString &tagText = KGlobal::staticQString( "text" );
+ static const TQString &tagText2 = KGlobal::staticQString( "Text" );
+ static const TQString &attrName = KGlobal::staticQString( "name" );
+
+ TQString name;
+ TQCString txt( it.namedItem( tagText ).toElement().text().utf8() );
+ if ( txt.isEmpty() )
+ txt = it.namedItem( tagText2 ).toElement().text().utf8();
+ if ( txt.isEmpty() )
+ name = it.attribute( attrName );
+ else
+ name = i18n( txt );
+
+ // the name of the toolbar might depend on whether or not
+ // it is in kparts
+ if ( ( xmlData.m_type == XmlData::Shell ) ||
+ ( xmlData.m_type == XmlData::Part ) )
+ {
+ TQString doc_name(xmlData.m_document.documentElement().attribute( attrName ));
+ name += " <" + doc_name + ">";
+ }
+ return name;
+ }
+ /**
+ * Look for a given item in the current toolbar
+ */
+ TQDomElement findElementForToolbarItem( const ToolbarItem* item ) const
+ {
+ static const TQString &attrName = KGlobal::staticQString( "name" );
+ for(TQDomNode n = m_currentToolbarElem.firstChild(); !n.isNull(); n = n.nextSibling())
+ {
+ TQDomElement elem = n.toElement();
+ if ((elem.attribute(attrName) == item->internalName()) &&
+ (elem.tagName() == item->internalTag()))
+ return elem;
+ }
+ return TQDomElement();
+ }
+
+#ifndef NDEBUG
+ void dump()
+ {
+ static const char* s_XmlTypeToString[] = { "Shell", "Part", "Local", "Merged" };
+ XmlDataList::Iterator xit = m_xmlFiles.begin();
+ for ( ; xit != m_xmlFiles.end(); ++xit )
+ {
+ kdDebug(240) << "XmlData type " << s_XmlTypeToString[(*xit).m_type] << " xmlFile: " << (*xit).m_xmlFile << endl;
+ for( TQValueList<TQDomElement>::Iterator it = (*xit).m_barList.begin();
+ it != (*xit).m_barList.end(); ++it ) {
+ kdDebug(240) << " Toolbar: " << toolbarName( *xit, *it ) << endl;
+ }
+ if ( (*xit).m_actionCollection )
+ kdDebug(240) << " " << (*xit).m_actionCollection->count() << " actions in the collection." << endl;
+ else
+ kdDebug(240) << " no action collection." << endl;
+ }
+ }
+#endif
+
+ //TQValueList<KAction*> m_actionList;
+ KActionCollection* m_collection;
+ KInstance *m_instance;
+
+ XmlData* m_currentXmlData;
+ TQDomElement m_currentToolbarElem;
+
+ TQString m_xmlFile;
+ TQString m_globalFile;
+ TQString m_rcFile;
+ TQDomDocument m_localDoc;
+ bool m_isPart;
+
+ ToolbarList m_barList;
+
+ XmlDataList m_xmlFiles;
+
+ TQLabel *m_comboLabel;
+ KSeparator *m_comboSeparator;
+ TQLabel * m_helpArea;
+ KPushButton* m_changeIcon;
+ KProcIO* m_kdialogProcess;
+ bool m_hasKDialog;
+};
+
+class KEditToolbarPrivate {
+public:
+ bool m_accept;
+
+ // Save parameters for recreating widget after resetting toolbar
+ bool m_global;
+ KActionCollection* m_collection;
+ TQString m_file;
+ KXMLGUIFactory* m_factory;
+};
+
+const char *KEditToolbar::s_defaultToolbar = 0L;
+
+KEditToolbar::KEditToolbar(KActionCollection *collection, const TQString& file,
+ bool global, TQWidget* parent, const char* name)
+ : KDialogBase(Swallow, i18n("Configure Toolbars"), Default|Ok|Apply|Cancel, Ok, parent, name),
+ m_widget(new KEditToolbarWidget(TQString::tqfromLatin1(s_defaultToolbar), collection, file, global, this))
+{
+ init();
+ d->m_global = global;
+ d->m_collection = collection;
+ d->m_file = file;
+}
+
+KEditToolbar::KEditToolbar(const TQString& defaultToolbar, KActionCollection *collection,
+ const TQString& file, bool global,
+ TQWidget* parent, const char* name)
+ : KDialogBase(Swallow, i18n("Configure Toolbars"), Default|Ok|Apply|Cancel, Ok, parent, name),
+ m_widget(new KEditToolbarWidget(defaultToolbar, collection, file, global, this))
+{
+ init();
+ d->m_global = global;
+ d->m_collection = collection;
+ d->m_file = file;
+}
+
+KEditToolbar::KEditToolbar(KXMLGUIFactory* factory, TQWidget* parent, const char* name)
+ : KDialogBase(Swallow, i18n("Configure Toolbars"), Default|Ok|Apply|Cancel, Ok, parent, name),
+ m_widget(new KEditToolbarWidget(TQString::tqfromLatin1(s_defaultToolbar), factory, this))
+{
+ init();
+ d->m_factory = factory;
+}
+
+KEditToolbar::KEditToolbar(const TQString& defaultToolbar,KXMLGUIFactory* factory,
+ TQWidget* parent, const char* name)
+ : KDialogBase(Swallow, i18n("Configure Toolbars"), Default|Ok|Apply|Cancel, Ok, parent, name),
+ m_widget(new KEditToolbarWidget(defaultToolbar, factory, this))
+{
+ init();
+ d->m_factory = factory;
+}
+
+void KEditToolbar::init()
+{
+ d = new KEditToolbarPrivate();
+ d->m_accept = false;
+ d->m_factory = 0;
+
+ setMainWidget(m_widget);
+
+ connect(m_widget, TQT_SIGNAL(enableOk(bool)), TQT_SLOT(acceptOK(bool)));
+ connect(m_widget, TQT_SIGNAL(enableOk(bool)), TQT_SLOT(enableButtonApply(bool)));
+ enableButtonApply(false);
+
+ setMinimumSize(tqsizeHint());
+ s_defaultToolbar = 0L;
+}
+
+KEditToolbar::~KEditToolbar()
+{
+ delete d;
+}
+
+void KEditToolbar::acceptOK(bool b)
+{
+ enableButtonOK(b);
+ d->m_accept = b;
+}
+
+void KEditToolbar::slotDefault()
+{
+ if ( KMessageBox::warningContinueCancel(this, i18n("Do you really want to reset all toolbars of this application to their default? The changes will be applied immediately."), i18n("Reset Toolbars"),i18n("Reset"))!=KMessageBox::Continue )
+ return;
+
+ delete m_widget;
+ d->m_accept = false;
+
+ if ( d->m_factory )
+ {
+ const TQString localPrefix = locateLocal("data", "");
+ TQPtrList<KXMLGUIClient> clients(d->m_factory->clients());
+ TQPtrListIterator<KXMLGUIClient> it( clients );
+
+ for( ; it.current(); ++it)
+ {
+ KXMLGUIClient *client = it.current();
+ TQString file = client->xmlFile();
+
+ if (file.isNull())
+ continue;
+
+ if (TQDir::isRelativePath(file))
+ {
+ const KInstance *instance = client->instance() ? client->instance() : KGlobal::instance();
+ file = locateLocal("data", TQString::tqfromLatin1( instance->instanceName() + '/' ) + file);
+ }
+ else
+ {
+ if (!file.startsWith(localPrefix))
+ continue;
+ }
+
+ if ( TQFile::exists( file ) )
+ if ( !TQFile::remove( file ) )
+ kdWarning() << "Could not delete " << file << endl;
+ }
+
+ m_widget = new KEditToolbarWidget(TQString::null, d->m_factory, this);
+ m_widget->rebuildKXMLGUIClients();
+ }
+ else
+ {
+ int slash = d->m_file.findRev('/')+1;
+ if (slash)
+ d->m_file = d->m_file.mid(slash);
+ TQString xml_file = locateLocal("data", TQString::tqfromLatin1( KGlobal::instance()->instanceName() + '/' ) + d->m_file);
+
+ if ( TQFile::exists( xml_file ) )
+ if ( !TQFile::remove( xml_file ) )
+ kdWarning() << "Could not delete " << xml_file << endl;
+
+ m_widget = new KEditToolbarWidget(TQString::null, d->m_collection, d->m_file, d->m_global, this);
+ }
+
+ setMainWidget(m_widget);
+ m_widget->show();
+
+ connect(m_widget, TQT_SIGNAL(enableOk(bool)), TQT_SLOT(acceptOK(bool)));
+ connect(m_widget, TQT_SIGNAL(enableOk(bool)), TQT_SLOT(enableButtonApply(bool)));
+
+ enableButtonApply(false);
+ emit newToolbarConfig();
+}
+
+void KEditToolbar::slotOk()
+{
+ if (!d->m_accept) {
+ reject();
+ return;
+ }
+
+ if (!m_widget->save())
+ {
+ // some error box here is needed
+ }
+ else
+ {
+ emit newToolbarConfig();
+ accept();
+ }
+}
+
+void KEditToolbar::slotApply()
+{
+ (void)m_widget->save();
+ enableButtonApply(false);
+ emit newToolbarConfig();
+}
+
+void KEditToolbar::setDefaultToolbar(const char *toolbarName)
+{
+ s_defaultToolbar = toolbarName;
+}
+
+KEditToolbarWidget::KEditToolbarWidget(KActionCollection *collection,
+ const TQString& file,
+ bool global, TQWidget *parent)
+ : TQWidget(parent),
+ d(new KEditToolbarWidgetPrivate(instance(), collection))
+{
+ initNonKPart(collection, file, global);
+ // now load in our toolbar combo box
+ loadToolbarCombo();
+ adjustSize();
+ setMinimumSize(tqsizeHint());
+}
+
+KEditToolbarWidget::KEditToolbarWidget(const TQString& defaultToolbar,
+ KActionCollection *collection,
+ const TQString& file, bool global,
+ TQWidget *parent)
+ : TQWidget(parent),
+ d(new KEditToolbarWidgetPrivate(instance(), collection))
+{
+ initNonKPart(collection, file, global);
+ // now load in our toolbar combo box
+ loadToolbarCombo(defaultToolbar);
+ adjustSize();
+ setMinimumSize(tqsizeHint());
+}
+
+KEditToolbarWidget::KEditToolbarWidget( KXMLGUIFactory* factory,
+ TQWidget *parent)
+ : TQWidget(parent),
+ d(new KEditToolbarWidgetPrivate(instance(), KXMLGUIClient::actionCollection() /*create new one*/))
+{
+ initKPart(factory);
+ // now load in our toolbar combo box
+ loadToolbarCombo();
+ adjustSize();
+ setMinimumSize(tqsizeHint());
+}
+
+KEditToolbarWidget::KEditToolbarWidget( const TQString& defaultToolbar,
+ KXMLGUIFactory* factory,
+ TQWidget *parent)
+ : TQWidget(parent),
+ d(new KEditToolbarWidgetPrivate(instance(), KXMLGUIClient::actionCollection() /*create new one*/))
+{
+ initKPart(factory);
+ // now load in our toolbar combo box
+ loadToolbarCombo(defaultToolbar);
+ adjustSize();
+ setMinimumSize(tqsizeHint());
+}
+
+KEditToolbarWidget::~KEditToolbarWidget()
+{
+ delete d;
+}
+
+void KEditToolbarWidget::initNonKPart(KActionCollection *collection,
+ const TQString& file, bool global)
+{
+ //d->m_actionList = collection->actions();
+
+ // handle the merging
+ if (global)
+ setXMLFile(locate("config", "ui/ui_standards.rc"));
+ TQString localXML = d->loadXMLFile(file);
+ setXML(localXML, true);
+
+ // reusable vars
+ TQDomElement elem;
+
+ // first, get all of the necessary info for our local xml
+ XmlData local;
+ local.m_xmlFile = d->xmlFile(file);
+ local.m_type = XmlData::Local;
+ local.m_document.setContent(localXML);
+ elem = local.m_document.documentElement().toElement();
+ local.m_barList = d->findToolbars(elem);
+ local.m_actionCollection = collection;
+ d->m_xmlFiles.append(local);
+
+ // then, the merged one (ui_standards + local xml)
+ XmlData merge;
+ merge.m_xmlFile = TQString::null;
+ merge.m_type = XmlData::Merged;
+ merge.m_document = domDocument();
+ elem = merge.m_document.documentElement().toElement();
+ merge.m_barList = d->findToolbars(elem);
+ merge.m_actionCollection = collection;
+ d->m_xmlFiles.append(merge);
+
+#ifndef NDEBUG
+ //d->dump();
+#endif
+
+ // okay, that done, we concern ourselves with the GUI aspects
+ setupLayout();
+}
+
+void KEditToolbarWidget::initKPart(KXMLGUIFactory* factory)
+{
+ // reusable vars
+ TQDomElement elem;
+
+ setFactory( factory );
+ actionCollection()->setWidget( this );
+
+ // add all of the client data
+ TQPtrList<KXMLGUIClient> clients(factory->clients());
+ TQPtrListIterator<KXMLGUIClient> it( clients );
+ for( ; it.current(); ++it)
+ {
+ KXMLGUIClient *client = it.current();
+
+ if (client->xmlFile().isNull())
+ continue;
+
+ XmlData data;
+ data.m_xmlFile = client->localXMLFile();
+ if ( it.atFirst() )
+ data.m_type = XmlData::Shell;
+ else
+ data.m_type = XmlData::Part;
+ data.m_document.setContent( KXMLGUIFactory::readConfigFile( client->xmlFile(), client->instance() ) );
+ elem = data.m_document.documentElement().toElement();
+ data.m_barList = d->findToolbars(elem);
+ data.m_actionCollection = client->actionCollection();
+ d->m_xmlFiles.append(data);
+
+ //d->m_actionList += client->actionCollection()->actions();
+ }
+
+#ifndef NDEBUG
+ //d->dump();
+#endif
+
+ // okay, that done, we concern ourselves with the GUI aspects
+ setupLayout();
+}
+
+bool KEditToolbarWidget::save()
+{
+ //kdDebug(240) << "KEditToolbarWidget::save" << endl;
+ XmlDataList::Iterator it = d->m_xmlFiles.begin();
+ for ( ; it != d->m_xmlFiles.end(); ++it)
+ {
+ // let's not save non-modified files
+ if ( !((*it).m_isModified) )
+ continue;
+
+ // let's also skip (non-existent) merged files
+ if ( (*it).m_type == XmlData::Merged )
+ continue;
+
+ dump_xml((*it).m_document);
+
+ kdDebug(240) << "Saving " << (*it).m_xmlFile << endl;
+ // if we got this far, we might as well just save it
+ KXMLGUIFactory::saveConfigFile((*it).m_document, (*it).m_xmlFile);
+ }
+
+ if ( !factory() )
+ return true;
+
+ rebuildKXMLGUIClients();
+
+ return true;
+}
+
+void KEditToolbarWidget::rebuildKXMLGUIClients()
+{
+ if ( !factory() )
+ return;
+
+ TQPtrList<KXMLGUIClient> clients(factory()->clients());
+ //kdDebug(240) << "factory: " << clients.count() << " clients" << endl;
+
+ // remove the elements starting from the last going to the first
+ KXMLGUIClient *client = clients.last();
+ while ( client )
+ {
+ //kdDebug(240) << "factory->removeClient " << client << endl;
+ factory()->removeClient( client );
+ client = clients.prev();
+ }
+
+ KXMLGUIClient *firstClient = clients.first();
+
+ // now, rebuild the gui from the first to the last
+ //kdDebug(240) << "rebuilding the gui" << endl;
+ TQPtrListIterator<KXMLGUIClient> cit( clients );
+ for( ; cit.current(); ++cit)
+ {
+ KXMLGUIClient* client = cit.current();
+ //kdDebug(240) << "updating client " << client << " " << client->instance()->instanceName() << " xmlFile=" << client->xmlFile() << endl;
+ TQString file( client->xmlFile() ); // before setting ui_standards!
+ if ( !file.isEmpty() )
+ {
+ // passing an empty stream forces the clients to reread the XML
+ client->setXMLGUIBuildDocument( TQDomDocument() );
+
+ // for the shell, merge in ui_standards.rc
+ if ( client == firstClient ) // same assumption as in the ctor: first==shell
+ client->setXMLFile(locate("config", "ui/ui_standards.rc"));
+
+ // and this forces it to use the *new* XML file
+ client->setXMLFile( file, client == firstClient /* merge if shell */ );
+ }
+ }
+
+ // Now we can add the clients to the factory
+ // We don't do it in the loop above because adding a part automatically
+ // adds its plugins, so we must make sure the plugins were updated first.
+ cit.toFirst();
+ for( ; cit.current(); ++cit)
+ factory()->addClient( cit.current() );
+}
+
+void KEditToolbarWidget::setupLayout()
+{
+ // the toolbar name combo
+ d->m_comboLabel = new TQLabel(i18n("&Toolbar:"), this);
+ m_toolbarCombo = new TQComboBox(this);
+ m_toolbarCombo->setEnabled(false);
+ d->m_comboLabel->setBuddy(m_toolbarCombo);
+ d->m_comboSeparator = new KSeparator(this);
+ connect(m_toolbarCombo, TQT_SIGNAL(activated(const TQString&)),
+ this, TQT_SLOT(slotToolbarSelected(const TQString&)));
+
+// TQPushButton *new_toolbar = new TQPushButton(i18n("&New"), this);
+// new_toolbar->setPixmap(BarIcon("filenew", KIcon::SizeSmall));
+// new_toolbar->setEnabled(false); // disabled until implemented
+// TQPushButton *del_toolbar = new TQPushButton(i18n("&Delete"), this);
+// del_toolbar->setPixmap(BarIcon("editdelete", KIcon::SizeSmall));
+// del_toolbar->setEnabled(false); // disabled until implemented
+
+ // our list of inactive actions
+ TQLabel *inactive_label = new TQLabel(i18n("A&vailable actions:"), this);
+ m_inactiveList = new ToolbarListView(this);
+ m_inactiveList->setDragEnabled(true);
+ m_inactiveList->setAcceptDrops(true);
+ m_inactiveList->setDropVisualizer(false);
+ m_inactiveList->setAllColumnsShowFocus(true);
+ m_inactiveList->setMinimumSize(180, 250);
+ m_inactiveList->header()->hide();
+ m_inactiveList->addColumn(""); // icon
+ int column2 = m_inactiveList->addColumn(""); // text
+ m_inactiveList->setSorting( column2 );
+ inactive_label->setBuddy(m_inactiveList);
+ connect(m_inactiveList, TQT_SIGNAL(selectionChanged(TQListViewItem *)),
+ this, TQT_SLOT(slotInactiveSelected(TQListViewItem *)));
+ connect(m_inactiveList, TQT_SIGNAL( doubleClicked( TQListViewItem *, const TQPoint &, int )),
+ this, TQT_SLOT(slotInsertButton()));
+
+ // our list of active actions
+ TQLabel *active_label = new TQLabel(i18n("Curr&ent actions:"), this);
+ m_activeList = new ToolbarListView(this);
+ m_activeList->setDragEnabled(true);
+ m_activeList->setAcceptDrops(true);
+ m_activeList->setDropVisualizer(true);
+ m_activeList->setAllColumnsShowFocus(true);
+ m_activeList->setMinimumWidth(m_inactiveList->minimumWidth());
+ m_activeList->header()->hide();
+ m_activeList->addColumn(""); // icon
+ m_activeList->addColumn(""); // text
+ m_activeList->setSorting(-1);
+ active_label->setBuddy(m_activeList);
+
+ connect(m_inactiveList, TQT_SIGNAL(dropped(KListView*,TQDropEvent*,TQListViewItem*)),
+ this, TQT_SLOT(slotDropped(KListView*,TQDropEvent*,TQListViewItem*)));
+ connect(m_activeList, TQT_SIGNAL(dropped(KListView*,TQDropEvent*,TQListViewItem*)),
+ this, TQT_SLOT(slotDropped(KListView*,TQDropEvent*,TQListViewItem*)));
+ connect(m_activeList, TQT_SIGNAL(selectionChanged(TQListViewItem *)),
+ this, TQT_SLOT(slotActiveSelected(TQListViewItem *)));
+ connect(m_activeList, TQT_SIGNAL( doubleClicked( TQListViewItem *, const TQPoint &, int )),
+ this, TQT_SLOT(slotRemoveButton()));
+
+ // "change icon" button
+ d->m_changeIcon = new KPushButton( i18n( "Change &Icon..." ), this );
+ TQString kdialogExe = KStandardDirs::findExe(TQString::tqfromLatin1("kdialog"));
+ d->m_hasKDialog = !kdialogExe.isEmpty();
+ d->m_changeIcon->setEnabled( d->m_hasKDialog );
+
+ connect( d->m_changeIcon, TQT_SIGNAL( clicked() ),
+ this, TQT_SLOT( slotChangeIcon() ) );
+
+ // The buttons in the middle
+ TQIconSet iconSet;
+
+ m_upAction = new TQToolButton(this);
+ iconSet = SmallIconSet( "up" );
+ m_upAction->setIconSet( iconSet );
+ m_upAction->setEnabled(false);
+ m_upAction->setAutoRepeat(true);
+ connect(m_upAction, TQT_SIGNAL(clicked()), TQT_SLOT(slotUpButton()));
+
+ m_insertAction = new TQToolButton(this);
+ iconSet = TQApplication::reverseLayout() ? SmallIconSet( "back" ) : SmallIconSet( "forward" );
+ m_insertAction->setIconSet( iconSet );
+ m_insertAction->setEnabled(false);
+ connect(m_insertAction, TQT_SIGNAL(clicked()), TQT_SLOT(slotInsertButton()));
+
+ m_removeAction = new TQToolButton(this);
+ iconSet = TQApplication::reverseLayout() ? SmallIconSet( "forward" ) : SmallIconSet( "back" );
+ m_removeAction->setIconSet( iconSet );
+ m_removeAction->setEnabled(false);
+ connect(m_removeAction, TQT_SIGNAL(clicked()), TQT_SLOT(slotRemoveButton()));
+
+ m_downAction = new TQToolButton(this);
+ iconSet = SmallIconSet( "down" );
+ m_downAction->setIconSet( iconSet );
+ m_downAction->setEnabled(false);
+ m_downAction->setAutoRepeat(true);
+ connect(m_downAction, TQT_SIGNAL(clicked()), TQT_SLOT(slotDownButton()));
+
+ d->m_helpArea = new TQLabel(this);
+ d->m_helpArea->tqsetAlignment( TQt::WordBreak );
+
+ // now start with our layouts
+ TQVBoxLayout *top_layout = new TQVBoxLayout(this, 0, KDialog::spacingHint());
+
+ TQVBoxLayout *name_layout = new TQVBoxLayout(KDialog::spacingHint());
+ TQHBoxLayout *list_layout = new TQHBoxLayout(KDialog::spacingHint());
+
+ TQVBoxLayout *inactive_layout = new TQVBoxLayout(KDialog::spacingHint());
+ TQVBoxLayout *active_layout = new TQVBoxLayout(KDialog::spacingHint());
+ TQHBoxLayout *changeIcon_layout = new TQHBoxLayout(KDialog::spacingHint());
+
+ TQGridLayout *button_layout = new TQGridLayout(5, 3, 0);
+
+ name_layout->addWidget(d->m_comboLabel);
+ name_layout->addWidget(m_toolbarCombo);
+// name_layout->addWidget(new_toolbar);
+// name_layout->addWidget(del_toolbar);
+
+ button_layout->setRowStretch( 0, 10 );
+ button_layout->addWidget(m_upAction, 1, 1);
+ button_layout->addWidget(m_removeAction, 2, 0);
+ button_layout->addWidget(m_insertAction, 2, 2);
+ button_layout->addWidget(m_downAction, 3, 1);
+ button_layout->setRowStretch( 4, 10 );
+
+ inactive_layout->addWidget(inactive_label);
+ inactive_layout->addWidget(m_inactiveList, 1);
+
+ active_layout->addWidget(active_label);
+ active_layout->addWidget(m_activeList, 1);
+ active_layout->addLayout(changeIcon_layout);
+
+ changeIcon_layout->addStretch( 1 );
+ changeIcon_layout->addWidget( d->m_changeIcon );
+ changeIcon_layout->addStretch( 1 );
+
+ list_layout->addLayout(inactive_layout);
+ list_layout->addLayout(TQT_TQLAYOUT(button_layout));
+ list_layout->addLayout(active_layout);
+
+ top_layout->addLayout(name_layout);
+ top_layout->addWidget(d->m_comboSeparator);
+ top_layout->addLayout(list_layout,10);
+ top_layout->addWidget(d->m_helpArea);
+ top_layout->addWidget(new KSeparator(this));
+}
+
+void KEditToolbarWidget::loadToolbarCombo(const TQString& defaultToolbar)
+{
+ static const TQString &attrName = KGlobal::staticQString( "name" );
+ // just in case, we clear our combo
+ m_toolbarCombo->clear();
+
+ int defaultToolbarId = -1;
+ int count = 0;
+ // load in all of the toolbar names into this combo box
+ XmlDataList::Iterator xit = d->m_xmlFiles.begin();
+ for ( ; xit != d->m_xmlFiles.end(); ++xit)
+ {
+ // skip the local one in favor of the merged
+ if ( (*xit).m_type == XmlData::Local )
+ continue;
+
+ // each xml file may have any number of toolbars
+ ToolbarList::Iterator it = (*xit).m_barList.begin();
+ for ( ; it != (*xit).m_barList.end(); ++it)
+ {
+ TQString name = d->toolbarName( *xit, *it );
+ m_toolbarCombo->setEnabled( true );
+ m_toolbarCombo->insertItem( name );
+ if (defaultToolbarId == -1 && (name == defaultToolbar || defaultToolbar == (*it).attribute( attrName )))
+ defaultToolbarId = count;
+ count++;
+ }
+ }
+ bool showCombo = (count > 1);
+ d->m_comboLabel->setShown(showCombo);
+ d->m_comboSeparator->setShown(showCombo);
+ m_toolbarCombo->setShown(showCombo);
+ if (defaultToolbarId == -1)
+ defaultToolbarId = 0;
+ // we want to the specified item selected and its actions loaded
+ m_toolbarCombo->setCurrentItem(defaultToolbarId);
+ slotToolbarSelected(m_toolbarCombo->currentText());
+}
+
+void KEditToolbarWidget::loadActionList(TQDomElement& elem)
+{
+ static const TQString &tagSeparator = KGlobal::staticQString( "Separator" );
+ static const TQString &tagMerge = KGlobal::staticQString( "Merge" );
+ static const TQString &tagActionList= KGlobal::staticQString( "ActionList" );
+ static const TQString &attrName = KGlobal::staticQString( "name" );
+ static const TQString &attrLineSeparator = KGlobal::staticQString( "lineSeparator" );
+
+ int sep_num = 0;
+ TQString sep_name("separator_%1");
+
+ // clear our lists
+ m_inactiveList->clear();
+ m_activeList->clear();
+ m_insertAction->setEnabled(false);
+ m_removeAction->setEnabled(false);
+ m_upAction->setEnabled(false);
+ m_downAction->setEnabled(false);
+
+ // We'll use this action collection
+ KActionCollection* actionCollection = d->m_currentXmlData->m_actionCollection;
+
+ // store the names of our active actions
+ TQMap<TQString, bool> active_list;
+
+ // see if our current action is in this toolbar
+ KIconLoader *loader = KGlobal::instance()->iconLoader();
+ TQDomNode n = elem.lastChild();
+ for( ; !n.isNull(); n = n.previousSibling() )
+ {
+ TQDomElement it = n.toElement();
+ if (it.isNull()) continue;
+ if (it.tagName() == tagSeparator)
+ {
+ ToolbarItem *act = new ToolbarItem(m_activeList, tagSeparator, sep_name.arg(sep_num++), TQString::null);
+ bool isLineSep = ( it.attribute(attrLineSeparator, "true").lower() == TQString::tqfromLatin1("true") );
+ if(isLineSep)
+ act->setText(1, LINESEPARATORSTRING);
+ else
+ act->setText(1, SEPARATORSTRING);
+ it.setAttribute( attrName, act->internalName() );
+ continue;
+ }
+
+ if (it.tagName() == tagMerge)
+ {
+ // Merge can be named or not - use the name if there is one
+ TQString name = it.attribute( attrName );
+ ToolbarItem *act = new ToolbarItem(m_activeList, tagMerge, name, i18n("This element will be replaced with all the elements of an embedded component."));
+ if ( name.isEmpty() )
+ act->setText(1, i18n("<Merge>"));
+ else
+ act->setText(1, i18n("<Merge %1>").arg(name));
+ continue;
+ }
+
+ if (it.tagName() == tagActionList)
+ {
+ ToolbarItem *act = new ToolbarItem(m_activeList, tagActionList, it.attribute(attrName), i18n("This is a dynamic list of actions. You can move it, but if you remove it you won't be able to re-add it.") );
+ act->setText(1, i18n("ActionList: %1").arg(it.attribute(attrName)));
+ continue;
+ }
+
+ // iterate through this client's actions
+ // This used to iterate through _all_ actions, but we don't support
+ // putting any action into any client...
+ for (unsigned int i = 0; i < actionCollection->count(); i++)
+ {
+ KAction *action = actionCollection->action( i );
+
+ // do we have a match?
+ if (it.attribute( attrName ) == action->name())
+ {
+ // we have a match!
+ ToolbarItem *act = new ToolbarItem(m_activeList, it.tagName(), action->name(), action->toolTip());
+ act->setText(1, action->plainText());
+ if (action->hasIcon())
+ if (!action->icon().isEmpty())
+ act->setPixmap(0, loader->loadIcon(action->icon(), KIcon::Toolbar, 16, KIcon::DefaultState, 0, true) );
+ else // Has iconset
+ act->setPixmap(0, action->iconSet(KIcon::Toolbar).pixmap());
+
+ active_list.insert(action->name(), true);
+ break;
+ }
+ }
+ }
+
+ // go through the rest of the collection
+ for (int i = actionCollection->count() - 1; i > -1; --i)
+ {
+ KAction *action = actionCollection->action( i );
+
+ // skip our active ones
+ if (active_list.contains(action->name()))
+ continue;
+
+ ToolbarItem *act = new ToolbarItem(m_inactiveList, tagActionList, action->name(), action->toolTip());
+ act->setText(1, action->plainText());
+ if (action->hasIcon())
+ if (!action->icon().isEmpty())
+ act->setPixmap(0, loader->loadIcon(action->icon(), KIcon::Toolbar, 16, KIcon::DefaultState, 0, true) );
+ else // Has iconset
+ act->setPixmap(0, action->iconSet(KIcon::Toolbar).pixmap());
+ }
+
+ // finally, add default separators to the inactive list
+ ToolbarItem *act = new ToolbarItem(m_inactiveList, tagSeparator, sep_name.arg(sep_num++), TQString::null);
+ act->setText(1, LINESEPARATORSTRING);
+ act = new ToolbarItem(m_inactiveList, tagSeparator, sep_name.arg(sep_num++), TQString::null);
+ act->setText(1, SEPARATORSTRING);
+}
+
+KActionCollection *KEditToolbarWidget::actionCollection() const
+{
+ return d->m_collection;
+}
+
+void KEditToolbarWidget::slotToolbarSelected(const TQString& _text)
+{
+ // iterate through everything
+ XmlDataList::Iterator xit = d->m_xmlFiles.begin();
+ for ( ; xit != d->m_xmlFiles.end(); ++xit)
+ {
+ // each xml file may have any number of toolbars
+ ToolbarList::Iterator it = (*xit).m_barList.begin();
+ for ( ; it != (*xit).m_barList.end(); ++it)
+ {
+ TQString name = d->toolbarName( *xit, *it );
+ // is this our toolbar?
+ if ( name == _text )
+ {
+ // save our current settings
+ d->m_currentXmlData = & (*xit);
+ d->m_currentToolbarElem = (*it);
+
+ // load in our values
+ loadActionList(d->m_currentToolbarElem);
+
+ if ((*xit).m_type == XmlData::Part || (*xit).m_type == XmlData::Shell)
+ setDOMDocument( (*xit).m_document );
+ return;
+ }
+ }
+ }
+}
+
+void KEditToolbarWidget::slotInactiveSelected(TQListViewItem *item)
+{
+ ToolbarItem* toolitem = static_cast<ToolbarItem *>(item);
+ if (item)
+ {
+ m_insertAction->setEnabled(true);
+ TQString statusText = toolitem->statusText();
+ d->m_helpArea->setText( statusText );
+ }
+ else
+ {
+ m_insertAction->setEnabled(false);
+ d->m_helpArea->setText( TQString::null );
+ }
+}
+
+void KEditToolbarWidget::slotActiveSelected(TQListViewItem *item)
+{
+ ToolbarItem* toolitem = static_cast<ToolbarItem *>(item);
+ m_removeAction->setEnabled( item );
+
+ static const TQString &tagAction = KGlobal::staticQString( "Action" );
+ d->m_changeIcon->setEnabled( item &&
+ d->m_hasKDialog &&
+ toolitem->internalTag() == tagAction );
+
+ if (item)
+ {
+ if (item->itemAbove())
+ m_upAction->setEnabled(true);
+ else
+ m_upAction->setEnabled(false);
+
+ if (item->itemBelow())
+ m_downAction->setEnabled(true);
+ else
+ m_downAction->setEnabled(false);
+ TQString statusText = toolitem->statusText();
+ d->m_helpArea->setText( statusText );
+ }
+ else
+ {
+ m_upAction->setEnabled(false);
+ m_downAction->setEnabled(false);
+ d->m_helpArea->setText( TQString::null );
+ }
+}
+
+void KEditToolbarWidget::slotDropped(KListView *list, TQDropEvent *e, TQListViewItem *after)
+{
+ ToolbarItem *item = new ToolbarItem(m_inactiveList); // needs parent, use inactiveList temporarily
+ if(!ToolbarItemDrag::decode(e, *item)) {
+ delete item;
+ return;
+ }
+
+ if (list == m_activeList) {
+ if (e->source() == m_activeList) {
+ // has been dragged within the active list (moved).
+ moveActive(item, after);
+ }
+ else
+ insertActive(item, after, true);
+ } else if (list == m_inactiveList) {
+ // has been dragged to the inactive list -> remove from the active list.
+ removeActive(item);
+ }
+
+ delete item; item = 0; // not neded anymore
+
+ // we're modified, so let this change
+ emit enableOk(true);
+
+ slotToolbarSelected( m_toolbarCombo->currentText() );
+}
+
+void KEditToolbarWidget::slotInsertButton()
+{
+ ToolbarItem *item = (ToolbarItem*)m_inactiveList->currentItem();
+ insertActive(item, m_activeList->currentItem(), false);
+
+ // we're modified, so let this change
+ emit enableOk(true);
+
+ // TODO: #### this causes #97572.
+ // It would be better to just "delete item; loadActions( ... , ActiveListOnly );" or something.
+ slotToolbarSelected( m_toolbarCombo->currentText() );
+}
+
+void KEditToolbarWidget::slotRemoveButton()
+{
+ removeActive( dynamic_cast<ToolbarItem*>(m_activeList->currentItem()) );
+
+ // we're modified, so let this change
+ emit enableOk(true);
+
+ slotToolbarSelected( m_toolbarCombo->currentText() );
+}
+
+void KEditToolbarWidget::insertActive(ToolbarItem *item, TQListViewItem *before, bool prepend)
+{
+ if (!item)
+ return;
+
+ static const TQString &tagAction = KGlobal::staticQString( "Action" );
+ static const TQString &tagSeparator = KGlobal::staticQString( "Separator" );
+ static const TQString &attrName = KGlobal::staticQString( "name" );
+ static const TQString &attrLineSeparator = KGlobal::staticQString( "lineSeparator" );
+ static const TQString &attrNoMerge = KGlobal::staticQString( "noMerge" );
+
+ TQDomElement new_item;
+ // let's handle the separator specially
+ if (item->text(1) == LINESEPARATORSTRING) {
+ new_item = domDocument().createElement(tagSeparator);
+ } else if (item->text(1) == SEPARATORSTRING) {
+ new_item = domDocument().createElement(tagSeparator);
+ new_item.setAttribute(attrLineSeparator, "false");
+ } else
+ new_item = domDocument().createElement(tagAction);
+ new_item.setAttribute(attrName, item->internalName());
+
+ if (before)
+ {
+ // we have the item in the active list which is before the new
+ // item.. so let's try our best to add our new item right after it
+ ToolbarItem *act_item = (ToolbarItem*)before;
+ TQDomElement elem = d->findElementForToolbarItem( act_item );
+ Q_ASSERT( !elem.isNull() );
+ d->m_currentToolbarElem.insertAfter(new_item, elem);
+ }
+ else
+ {
+ // simply put it at the beginning or the end of the list.
+ if (prepend)
+ d->m_currentToolbarElem.insertBefore(new_item, d->m_currentToolbarElem.firstChild());
+ else
+ d->m_currentToolbarElem.appendChild(new_item);
+ }
+
+ // and set this container as a noMerge
+ d->m_currentToolbarElem.setAttribute( attrNoMerge, "1");
+
+ // update the local doc
+ updateLocal(d->m_currentToolbarElem);
+}
+
+void KEditToolbarWidget::removeActive(ToolbarItem *item)
+{
+ if (!item)
+ return;
+
+ static const TQString &attrNoMerge = KGlobal::staticQString( "noMerge" );
+
+ // we're modified, so let this change
+ emit enableOk(true);
+
+ // now iterate through to find the child to nuke
+ TQDomElement elem = d->findElementForToolbarItem( item );
+ if ( !elem.isNull() )
+ {
+ // nuke myself!
+ d->m_currentToolbarElem.removeChild(elem);
+
+ // and set this container as a noMerge
+ d->m_currentToolbarElem.setAttribute( attrNoMerge, "1");
+
+ // update the local doc
+ updateLocal(d->m_currentToolbarElem);
+ }
+}
+
+void KEditToolbarWidget::slotUpButton()
+{
+ ToolbarItem *item = (ToolbarItem*)m_activeList->currentItem();
+
+ // make sure we're not the top item already
+ if (!item->itemAbove())
+ return;
+
+ // we're modified, so let this change
+ emit enableOk(true);
+
+ moveActive( item, item->itemAbove()->itemAbove() );
+ delete item;
+}
+
+void KEditToolbarWidget::moveActive( ToolbarItem* item, TQListViewItem* before )
+{
+ TQDomElement e = d->findElementForToolbarItem( item );
+
+ if ( e.isNull() )
+ return;
+
+ // cool, i found me. now clone myself
+ ToolbarItem *clone = new ToolbarItem(m_activeList,
+ before,
+ item->internalTag(),
+ item->internalName(),
+ item->statusText());
+
+ clone->setText(1, item->text(1));
+
+ // only set new pixmap if exists
+ if( item->pixmap(0) )
+ clone->setPixmap(0, *item->pixmap(0));
+
+ // select my clone
+ m_activeList->setSelected(clone, true);
+
+ // make clone visible
+ m_activeList->ensureItemVisible(clone);
+
+ // and do the real move in the DOM
+ if ( !before )
+ d->m_currentToolbarElem.insertBefore(e, d->m_currentToolbarElem.firstChild() );
+ else
+ d->m_currentToolbarElem.insertAfter(e, d->findElementForToolbarItem( (ToolbarItem*)before ));
+
+ // and set this container as a noMerge
+ static const TQString &attrNoMerge = KGlobal::staticQString( "noMerge" );
+ d->m_currentToolbarElem.setAttribute( attrNoMerge, "1");
+
+ // update the local doc
+ updateLocal(d->m_currentToolbarElem);
+}
+
+void KEditToolbarWidget::slotDownButton()
+{
+ ToolbarItem *item = (ToolbarItem*)m_activeList->currentItem();
+
+ // make sure we're not the bottom item already
+ if (!item->itemBelow())
+ return;
+
+ // we're modified, so let this change
+ emit enableOk(true);
+
+ moveActive( item, item->itemBelow() );
+ delete item;
+}
+
+void KEditToolbarWidget::updateLocal(TQDomElement& elem)
+{
+ static const TQString &attrName = KGlobal::staticQString( "name" );
+
+ XmlDataList::Iterator xit = d->m_xmlFiles.begin();
+ for ( ; xit != d->m_xmlFiles.end(); ++xit)
+ {
+ if ( (*xit).m_type == XmlData::Merged )
+ continue;
+
+ if ( (*xit).m_type == XmlData::Shell ||
+ (*xit).m_type == XmlData::Part )
+ {
+ if ( d->m_currentXmlData->m_xmlFile == (*xit).m_xmlFile )
+ {
+ (*xit).m_isModified = true;
+ return;
+ }
+
+ continue;
+ }
+
+ (*xit).m_isModified = true;
+
+ ToolbarList::Iterator it = (*xit).m_barList.begin();
+ for ( ; it != (*xit).m_barList.end(); ++it)
+ {
+ TQString name( (*it).attribute( attrName ) );
+ TQString tag( (*it).tagName() );
+ if ( (tag != elem.tagName()) || (name != elem.attribute(attrName)) )
+ continue;
+
+ TQDomElement toolbar = (*xit).m_document.documentElement().toElement();
+ toolbar.replaceChild(elem, (*it));
+ return;
+ }
+
+ // just append it
+ TQDomElement toolbar = (*xit).m_document.documentElement().toElement();
+ toolbar.appendChild(elem);
+ }
+}
+
+void KEditToolbarWidget::slotChangeIcon()
+{
+ // We can't use KIconChooser here, since it's in libkio
+ // ##### KDE4: reconsider this, e.g. move KEditToolbar to libkio
+
+ //if the process is already running (e.g. when somebody clicked the change button twice (see #127149)) - do nothing...
+ //otherwise m_kdialogProcess will be overwritten and set to zero in slotProcessExited()...crash!
+ if ( d->m_kdialogProcess && d->m_kdialogProcess->isRunning() )
+ return;
+
+ d->m_kdialogProcess = new KProcIO;
+ TQString kdialogExe = KStandardDirs::findExe(TQString::tqfromLatin1("kdialog"));
+ (*d->m_kdialogProcess) << kdialogExe;
+ (*d->m_kdialogProcess) << "--embed";
+ (*d->m_kdialogProcess) << TQString::number( (ulong)tqtopLevelWidget()->winId() );
+ (*d->m_kdialogProcess) << "--geticon";
+ (*d->m_kdialogProcess) << "Toolbar";
+ (*d->m_kdialogProcess) << "Actions";
+ if ( !d->m_kdialogProcess->start( KProcess::NotifyOnExit ) ) {
+ kdError(240) << "Can't run " << kdialogExe << endl;
+ delete d->m_kdialogProcess;
+ d->m_kdialogProcess = 0;
+ return;
+ }
+
+ m_activeList->setEnabled( false ); // don't change the current item
+ m_toolbarCombo->setEnabled( false ); // don't change the current toolbar
+
+ connect( d->m_kdialogProcess, TQT_SIGNAL( processExited( KProcess* ) ),
+ this, TQT_SLOT( slotProcessExited( KProcess* ) ) );
+}
+
+void KEditToolbarWidget::slotProcessExited( KProcess* )
+{
+ m_activeList->setEnabled( true );
+ m_toolbarCombo->setEnabled( true );
+
+ TQString icon;
+
+ if (!d->m_kdialogProcess) {
+ kdError(240) << "Something is wrong here! m_kdialogProcess is zero!" << endl;
+ return;
+ }
+
+ if ( !d->m_kdialogProcess->normalExit() ||
+ d->m_kdialogProcess->exitStatus() ||
+ d->m_kdialogProcess->readln(icon, true) <= 0 ) {
+ delete d->m_kdialogProcess;
+ d->m_kdialogProcess = 0;
+ return;
+ }
+
+ ToolbarItem *item = (ToolbarItem*)m_activeList->currentItem();
+ if(item){
+ item->setPixmap(0, BarIcon(icon, 16));
+
+ Q_ASSERT( d->m_currentXmlData->m_type != XmlData::Merged );
+
+ d->m_currentXmlData->m_isModified = true;
+
+ // Get hold of ActionProperties tag
+ TQDomElement elem = KXMLGUIFactory::actionPropertiesElement( d->m_currentXmlData->m_document );
+ // Find or create an element for this action
+ TQDomElement act_elem = KXMLGUIFactory::findActionByName( elem, item->internalName(), true /*create*/ );
+ Q_ASSERT( !act_elem.isNull() );
+ act_elem.setAttribute( "icon", icon );
+
+ // we're modified, so let this change
+ emit enableOk(true);
+ }
+
+ delete d->m_kdialogProcess;
+ d->m_kdialogProcess = 0;
+}
+
+void KEditToolbar::virtual_hook( int id, void* data )
+{ KDialogBase::virtual_hook( id, data ); }
+
+void KEditToolbarWidget::virtual_hook( int id, void* data )
+{ KXMLGUIClient::virtual_hook( id, data ); }
+
+#include "kedittoolbar.moc"