kdeui/xmlgui/kxmlguifactory.cpp

   1 /* This file is part of the KDE libraries
   2    Copyright (C) 1999,2000 Simon Hausmann <hausmann@kde.org>
   3    Copyright (C) 2000 Kurt Granroth <granroth@kde.org>
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public
   7    License as published by the Free Software Foundation; either
   8    version 2 of the License, or (at your option) any later version.
   9
  10    This library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public License
  16    along with this library; see the file COPYING.LIB.  If not, write to
  17    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18    Boston, MA 02110-1301, USA.
  19 */
  20
  21 #include "kxmlguifactory.h"
  22 #include "kxmlguifactory_p.h"
  23 #include "kxmlguiclient.h"
  24 #include "kxmlguibuilder.h"
  25
  26 #include <assert.h>
  27
  28 #include <QtCore/QDir>
  29 #include <QtXml/QDomDocument>
  30 #include <QtCore/QFile>
  31 #include <QtCore/QTextIStream>
  32 #include <QtGui/QWidget>
  33 #include <QtCore/QDate>
  34 #include <QtCore/QVariant>
  35 #include <QTextCodec>
  36
  37 #include <kdebug.h>
  38 #include <kcomponentdata.h>
  39 #include <kglobal.h>
  40 #include <kshortcut.h>
  41 #include <kstandarddirs.h>
  42
  43 #include "kaction.h"
  44 #include "kshortcutsdialog.h"
  45 #include "kactioncollection.h"
  46
  47 using namespace KXMLGUI;
  48
  49 class KXMLGUIFactoryPrivate : public BuildState
  50 {
  51 public:
  52     enum ShortcutOption { SetActiveShortcut = 1, SetDefaultShortcut = 2};
  53
  54     KXMLGUIFactoryPrivate()
  55     {
  56         static const QString &defaultMergingName = KGlobal::staticQString( "<default>" );
  57         static const QString &actionList = KGlobal::staticQString( "actionlist" );
  58         static const QString &name = KGlobal::staticQString( "name" );
  59
  60         m_rootNode = new ContainerNode( 0L, QString(), 0L );
  61         m_defaultMergingName = defaultMergingName;
  62         tagActionList = actionList;
  63         attrName = name;
  64     }
  65     ~KXMLGUIFactoryPrivate()
  66     {
  67         delete m_rootNode;
  68     }
  69
  70     void pushState()
  71     {
  72         m_stateStack.push( *this );
  73     }
  74
  75     void popState()
  76     {
  77         BuildState::operator=( m_stateStack.pop() );
  78     }
  79
  80     bool emptyState() const { return m_stateStack.isEmpty(); }
  81
  82     QWidget *findRecursive( KXMLGUI::ContainerNode *node, bool tag );
  83     QList<QWidget*> findRecursive( KXMLGUI::ContainerNode *node, const QString &tagName );
  84     void applyActionProperties( const QDomElement &element,
  85         ShortcutOption shortcutOption = KXMLGUIFactoryPrivate::SetActiveShortcut );
  86     void configureAction( QAction *action, const QDomNamedNodeMap &attributes,
  87         ShortcutOption shortcutOption = KXMLGUIFactoryPrivate::SetActiveShortcut );
  88     void configureAction( QAction *action, const QDomAttr &attribute,
  89         ShortcutOption shortcutOption = KXMLGUIFactoryPrivate::SetActiveShortcut );
  90
  91     QDomDocument shortcutSchemeDoc(KXMLGUIClient *client);
  92     void applyShortcutScheme(KXMLGUIClient *client, QDomDocument scheme);
  93     void refreshActionProperties(KXMLGUIClient *client, QDomDocument doc);
  94     void saveDefaultActionProperties(KXMLGUIClient *client);
  95
  96     ContainerNode *m_rootNode;
  97
  98     QString m_defaultMergingName;
  99
 100     /*
 101      * Contains the container which is searched for in ::container .
 102      */
 103     QString m_containerName;
 104
 105     /*
 106      * List of all clients
 107      */
 108     QList<KXMLGUIClient*> m_clients;
 109
 110     QString tagActionList;
 111
 112     QString attrName;
 113
 114     BuildStateStack m_stateStack;
 115 };
 116
 117 QString KXMLGUIFactory::readConfigFile( const QString &filename, const KComponentData &_componentData )
 118 {
 119     KComponentData componentData = _componentData.isValid() ? _componentData : KGlobal::mainComponent();
 120     QString xml_file;
 121
 122     if (!QDir::isRelativePath(filename))
 123         xml_file = filename;
 124     else
 125     {
 126         xml_file = KStandardDirs::locate("data", componentData.componentName() + '/' + filename);
 127         if ( !QFile::exists( xml_file ) )
 128           xml_file = KStandardDirs::locate( "data", filename );
 129     }
 130
 131     QFile file( xml_file );
 132     if ( xml_file.isEmpty() || !file.open( QIODevice::ReadOnly ) )
 133     {
 134         kError(240) << "No such XML file" << filename;
 135         return QString();
 136     }
 137
 138     QByteArray buffer(file.readAll());
 139     return QString::fromUtf8(buffer.constData(), buffer.size());
 140 }
 141
 142 bool KXMLGUIFactory::saveConfigFile( const QDomDocument& doc,
 143                                      const QString& filename, const KComponentData &_componentData )
 144 {
 145     KComponentData componentData = _componentData.isValid() ? _componentData : KGlobal::mainComponent();
 146     QString xml_file(filename);
 147
 148     if (QDir::isRelativePath(xml_file))
 149         xml_file = KStandardDirs::locateLocal("data", componentData.componentName() + '/' + filename);
 150
 151     QFile file( xml_file );
 152     if ( xml_file.isEmpty() || !file.open( QIODevice::WriteOnly ) )
 153     {
 154         kError(240) << "Could not write to" << filename;
 155         return false;
 156     }
 157
 158     // write out our document
 159     QTextStream ts(&file);
 160     ts.setCodec( QTextCodec::codecForName( "UTF-8" ) );
 161     ts << doc;
 162
 163     file.close();
 164     return true;
 165 }
 166
 167 /**
 168  * Removes all QDomComment objects from the specified node and all its children.
 169  */
 170 static void removeDOMComments( QDomNode &node )
 171 {
 172     QDomNode n = node.firstChild();
 173     while ( !n.isNull() )
 174     {
 175         if ( n.nodeType() == QDomNode::CommentNode )
 176         {
 177             QDomNode tmp = n;
 178             n = n.nextSibling();
 179             node.removeChild( tmp );
 180         }
 181         else
 182         {
 183             QDomNode tmp = n;
 184             n = n.nextSibling();
 185             removeDOMComments( tmp );
 186         }
 187     }
 188 }
 189
 190 KXMLGUIFactory::KXMLGUIFactory( KXMLGUIBuilder *builder, QObject *parent )
 191     : QObject( parent ),d(new KXMLGUIFactoryPrivate)
 192 {
 193     d->builder = builder;
 194     d->guiClient = 0;
 195     if ( d->builder )
 196     {
 197         d->builderContainerTags = d->builder->containerTags();
 198         d->builderCustomTags = d->builder->customTags();
 199     }
 200 }
 201
 202 KXMLGUIFactory::~KXMLGUIFactory()
 203 {
 204     delete d;
 205 }
 206
 207 void KXMLGUIFactory::addClient( KXMLGUIClient *client )
 208 {
 209     //kDebug(260) << client;
 210     if ( client->factory() ) {
 211         if ( client->factory() == this )
 212             return;
 213         else
 214             client->factory()->removeClient( client ); //just in case someone does stupid things ;-)
 215     }
 216
 217     if (d->emptyState())
 218         emit makingChanges(true);
 219     d->pushState();
 220
 221 //    QTime dt; dt.start();
 222
 223     d->guiClient = client;
 224
 225     // add this client to our client list
 226     if ( !d->m_clients.contains( client ) )
 227         d->m_clients.append( client );
 228     else
 229         kDebug(260) << "XMLGUI client already added " << client;
 230
 231     // Tell the client that plugging in is process and
 232     //  let it know what builder widget its mainwindow shortcuts
 233     //  should be attached to.
 234     client->beginXMLPlug( d->builder->widget() );
 235
 236     // try to use the build document for building the client's GUI, as the build document
 237     // contains the correct container state information (like toolbar positions, sizes, etc.) .
 238     // if there is non available, then use the "real" document.
 239     QDomDocument doc = client->xmlguiBuildDocument();
 240     if ( doc.documentElement().isNull() )
 241         doc = client->domDocument();
 242
 243     QDomElement docElement = doc.documentElement();
 244
 245     d->m_rootNode->index = -1;
 246
 247     // cache some variables
 248
 249     d->clientName = docElement.attribute( d->attrName );
 250     d->clientBuilder = client->clientBuilder();
 251
 252     if ( d->clientBuilder )
 253     {
 254         d->clientBuilderContainerTags = d->clientBuilder->containerTags();
 255         d->clientBuilderCustomTags = d->clientBuilder->customTags();
 256     }
 257     else
 258     {
 259         d->clientBuilderContainerTags.clear();
 260         d->clientBuilderCustomTags.clear();
 261     }
 262
 263     // load shortcut schemes, user-defined shortcuts and other action properties
 264     d->saveDefaultActionProperties(client);
 265     d->refreshActionProperties(client, doc);
 266
 267     BuildHelper( *d, d->m_rootNode ).build( docElement );
 268
 269     // let the client know that we built its GUI.
 270     client->setFactory( this );
 271
 272     // call the finalizeGUI method, to fix up the positions of toolbars for example.
 273     // ### FIXME : obey client builder
 274     // --- Well, toolbars have a bool "positioned", so it doesn't really matter,
 275     // if we call positionYourself on all of them each time. (David)
 276     d->builder->finalizeGUI( d->guiClient );
 277
 278     // reset some variables, for safety
 279     d->BuildState::reset();
 280
 281     client->endXMLPlug();
 282
 283     d->popState();
 284
 285     emit clientAdded( client );
 286
 287     // build child clients
 288     foreach (KXMLGUIClient *child, client->childClients())
 289         addClient( child );
 290
 291     if (d->emptyState())
 292         emit makingChanges(false);
 293 /*
 294     QString unaddedActions;
 295     foreach (KActionCollection* ac, KActionCollection::allCollections())
 296       foreach (QAction* action, ac->actions())
 297         if (action->associatedWidgets().isEmpty())
 298           unaddedActions += action->objectName() + ' ';
 299
 300     if (!unaddedActions.isEmpty())
 301       kWarning() << "The following actions are not plugged into the gui (shortcuts will not work): " << unaddedActions;
 302 */
 303
 304 //    kDebug() << "addClient took " << dt.elapsed();
 305 }
 306
 307 void KXMLGUIFactory::refreshActionProperties()
 308 {
 309     foreach (KXMLGUIClient *client, d->m_clients)
 310     {
 311         d->guiClient = client;
 312         QDomDocument doc = client->xmlguiBuildDocument();
 313         if ( doc.documentElement().isNull() )
 314         {
 315             client->reloadXML();
 316             doc = client->domDocument();
 317         }
 318         d->refreshActionProperties(client, doc);
 319     }
 320     d->guiClient = 0;
 321 }
 322
 323 void KXMLGUIFactoryPrivate::refreshActionProperties(KXMLGUIClient *client, QDomDocument doc)
 324 {
 325     // try to find and apply shortcuts schemes
 326     QDomDocument scheme = shortcutSchemeDoc(client);
 327     applyShortcutScheme(client, scheme);
 328
 329     // try to find and apply user-defined shortcuts
 330     QDomElement actionPropElement = KXMLGUIFactory::actionPropertiesElement(doc);
 331     if (actionPropElement.childNodes().isEmpty())
 332         doc.documentElement().removeChild(actionPropElement);
 333
 334     if ( !actionPropElement.isNull() )
 335         applyActionProperties( actionPropElement );
 336 }
 337
 338 void KXMLGUIFactoryPrivate::saveDefaultActionProperties(KXMLGUIClient *client)
 339 {
 340     // This method is called every time the user activated a new
 341     // kxmlguiclient. We only want to execute the following code only once in
 342     // the lifetime of an action.
 343     foreach (QAction *action, client->actionCollection()->actions())
 344     {
 345         // Skip actions we have seen already.
 346         if (action->property("_k_DefaultShortcut").isValid()) continue;
 347
 348         if (KAction* kaction = qobject_cast<KAction*>(action))
 349         {
 350             // Check if the default shortcut is set
 351             KShortcut defaultShortcut = kaction->shortcut(KAction::DefaultShortcut);
 352             KShortcut activeShortcut  = kaction->shortcut(KAction::ActiveShortcut);
 353
 354             // Check if we have an empty default shortcut and an non empty
 355             // custom shortcut. This should only happen if a developer called
 356             // QAction::setShortcut on an KAction. Print out a warning and
 357             // correct the mistake
 358             if ((!activeShortcut.isEmpty()) && defaultShortcut.isEmpty())
 359             {
 360                 kError() << "Shortcut for KAction " << kaction->objectName() << kaction->text() << "set with QShortcut::setShortcut()! See KAction documentation.";
 361                 kaction->setProperty("_k_DefaultShortcut", activeShortcut);
 362             }
 363             else
 364             {
 365                 kaction->setProperty("_k_DefaultShortcut", defaultShortcut);
 366             }
 367         }
 368         else
 369         {
 370             // A QAction used with KXMLGUI? Set our property and ignore it.
 371             kError() << "Attempt to use QAction" << action->objectName() << "with KXMLGUIFactory!";
 372             action->setProperty("_k_DefaultShortcut", KShortcut());
 373         }
 374
 375     }
 376 }
 377
 378 void KXMLGUIFactory::changeShortcutScheme(const QString &scheme)
 379 {
 380     kDebug(260) << "Changing shortcut scheme to" << scheme;
 381     KConfigGroup cg = KGlobal::config()->group( "Shortcut Schemes" );
 382     cg.writeEntry("Current Scheme", scheme);
 383
 384     refreshActionProperties();
 385 }
 386
 387 void KXMLGUIFactory::removeClient( KXMLGUIClient *client )
 388 {
 389     //kDebug(260) << client;
 390
 391     // don't try to remove the client's GUI if we didn't build it
 392     if ( !client || client->factory() != this )
 393         return;
 394
 395     if (d->emptyState())
 396         emit makingChanges(true);
 397
 398     // remove this client from our client list
 399     d->m_clients.removeAll( client );
 400
 401     // remove child clients first (create a copy of the list just in case the
 402     // original list is modified directly or indirectly in removeClient())
 403     const QList<KXMLGUIClient*> childClients(client->childClients());
 404     foreach (KXMLGUIClient *child, childClients)
 405         removeClient(child);
 406
 407     //kDebug(260) << "calling removeRecursive";
 408
 409     d->pushState();
 410
 411     // cache some variables
 412
 413     d->guiClient = client;
 414     d->clientName = client->domDocument().documentElement().attribute( d->attrName );
 415     d->clientBuilder = client->clientBuilder();
 416
 417     client->setFactory( 0L );
 418
 419     // if we don't have a build document for that client, yet, then create one by
 420     // cloning the original document, so that saving container information in the
 421     // DOM tree does not touch the original document.
 422     QDomDocument doc = client->xmlguiBuildDocument();
 423     if ( doc.documentElement().isNull() )
 424     {
 425         doc = client->domDocument().cloneNode( true ).toDocument();
 426         client->setXMLGUIBuildDocument( doc );
 427     }
 428
 429     d->m_rootNode->destruct( doc.documentElement(), *d );
 430
 431     // reset some variables
 432     d->BuildState::reset();
 433
 434     // This will destruct the KAccel object built around the given widget.
 435     client->prepareXMLUnplug( d->builder->widget() );
 436
 437     d->popState();
 438
 439     if (d->emptyState())
 440         emit makingChanges(false);
 441
 442     emit clientRemoved( client );
 443 }
 444
 445 QList<KXMLGUIClient*> KXMLGUIFactory::clients() const
 446 {
 447     return d->m_clients;
 448 }
 449
 450 QWidget *KXMLGUIFactory::container( const QString &containerName, KXMLGUIClient *client,
 451                                     bool useTagName )
 452 {
 453     d->pushState();
 454     d->m_containerName = containerName;
 455     d->guiClient = client;
 456
 457     QWidget *result = d->findRecursive( d->m_rootNode, useTagName );
 458
 459     d->guiClient = 0L;
 460     d->m_containerName.clear();
 461
 462     d->popState();
 463
 464     return result;
 465 }
 466
 467 QList<QWidget*> KXMLGUIFactory::containers( const QString &tagName )
 468 {
 469     return d->findRecursive( d->m_rootNode, tagName );
 470 }
 471
 472 void KXMLGUIFactory::reset()
 473 {
 474     d->m_rootNode->reset();
 475
 476     d->m_rootNode->clearChildren();
 477 }
 478
 479 void KXMLGUIFactory::resetContainer( const QString &containerName, bool useTagName )
 480 {
 481     if ( containerName.isEmpty() )
 482         return;
 483
 484     ContainerNode *container = d->m_rootNode->findContainer( containerName, useTagName );
 485
 486     if ( !container )
 487         return;
 488
 489     ContainerNode *parent = container->parent;
 490     if ( !parent )
 491         return;
 492
 493     //  resetInternal( container );
 494
 495     parent->removeChild( container );
 496 }
 497
 498 QWidget *KXMLGUIFactoryPrivate::findRecursive( KXMLGUI::ContainerNode *node, bool tag )
 499 {
 500     if ( ( ( !tag && node->name == m_containerName ) ||
 501            ( tag && node->tagName == m_containerName ) ) &&
 502          ( !guiClient || node->client == guiClient ) )
 503         return node->container;
 504
 505     foreach (ContainerNode* child, node->children)
 506     {
 507         QWidget *cont = findRecursive( child, tag );
 508         if ( cont )
 509             return cont;
 510     }
 511
 512     return 0L;
 513 }
 514
 515 // Case insensitive equality without calling toLower which allocates a new string
 516 static inline bool equals(const QString& str1, const char* str2)
 517 {
 518     return str1.compare(QLatin1String(str2), Qt::CaseInsensitive) == 0;
 519 }
 520 static inline bool equals(const QString& str1, const QString& str2)
 521 {
 522     return str1.compare(str2, Qt::CaseInsensitive) == 0;
 523 }
 524
 525
 526 QList<QWidget*> KXMLGUIFactoryPrivate::findRecursive( KXMLGUI::ContainerNode *node,
 527                                                       const QString &tagName )
 528 {
 529     QList<QWidget*> res;
 530
 531     if ( equals(node->tagName, tagName) )
 532         res.append( node->container );
 533
 534     foreach (KXMLGUI::ContainerNode* child, node->children)
 535         res << findRecursive( child, tagName );
 536
 537     return res;
 538 }
 539
 540 void KXMLGUIFactory::plugActionList( KXMLGUIClient *client, const QString &name,
 541                                      const QList<QAction*> &actionList )
 542 {
 543     d->pushState();
 544     d->guiClient = client;
 545     d->actionListName = name;
 546     d->actionList = actionList;
 547     d->clientName = client->domDocument().documentElement().attribute( d->attrName );
 548
 549     d->m_rootNode->plugActionList( *d );
 550
 551     d->BuildState::reset();
 552     d->popState();
 553 }
 554
 555 void KXMLGUIFactory::unplugActionList( KXMLGUIClient *client, const QString &name )
 556 {
 557     d->pushState();
 558     d->guiClient = client;
 559     d->actionListName = name;
 560     d->clientName = client->domDocument().documentElement().attribute( d->attrName );
 561
 562     d->m_rootNode->unplugActionList( *d );
 563
 564     d->BuildState::reset();
 565     d->popState();
 566 }
 567
 568 void KXMLGUIFactoryPrivate::applyActionProperties( const QDomElement &actionPropElement,
 569         ShortcutOption shortcutOption )
 570 {
 571     for (QDomNode n = actionPropElement.firstChild();
 572          !n.isNull(); n = n.nextSibling() )
 573     {
 574         QDomElement e = n.toElement();
 575         if ( !equals(e.tagName(), "action") )
 576             continue;
 577
 578         QAction *action = guiClient->action( e );
 579         if ( !action )
 580             continue;
 581
 582         configureAction( action, e.attributes(), shortcutOption );
 583     }
 584 }
 585
 586 void KXMLGUIFactoryPrivate::configureAction( QAction *action, const QDomNamedNodeMap &attributes,
 587         ShortcutOption shortcutOption )
 588 {
 589     for ( uint i = 0; i < attributes.length(); i++ )
 590     {
 591         QDomAttr attr = attributes.item( i ).toAttr();
 592         if ( attr.isNull() )
 593             continue;
 594
 595         configureAction( action, attr, shortcutOption );
 596     }
 597 }
 598
 599 void KXMLGUIFactoryPrivate::configureAction( QAction *action, const QDomAttr &attribute,
 600         ShortcutOption shortcutOption )
 601 {
 602     static const QString &attrShortcut = KGlobal::staticQString( "shortcut" );
 603
 604     QString attrName = attribute.name();
 605     // If the attribute is a deprecated "accel", change to "shortcut".
 606     if ( equals(attrName, "accel") )
 607         attrName = attrShortcut;
 608
 609     // No need to re-set name, particularly since it's "objectName" in Qt4
 610     if ( equals(attrName, "name") )
 611         return;
 612
 613     if ( equals(attrName, "icon") ) {
 614         action->setIcon( KIcon( attribute.value() ) );
 615         return;
 616     }
 617
 618     QVariant propertyValue;
 619
 620     QVariant::Type propertyType = action->property( attrName.toLatin1() ).type();
 621
 622     if ( propertyType == QVariant::Int ) {
 623         propertyValue = QVariant( attribute.value().toInt() );
 624     } else if ( propertyType == QVariant::UInt ) {
 625         propertyValue = QVariant( attribute.value().toUInt() );
 626     } else if ( propertyType == QVariant::UserType && action->property( attrName.toLatin1() ).userType() == qMetaTypeId<KShortcut>() ) {
 627         // Setting the shortcut by property also sets the default shortcut (which is incorrect), so we have to do it directly
 628         if (KAction* ka = qobject_cast<KAction*>(action)) {
 629             if (attrName=="globalShortcut") {
 630                 ka->setGlobalShortcut(KShortcut(attribute.value()), KAction::ActiveShortcut);
 631             } else {
 632                 ka->setShortcut(KShortcut(attribute.value()), KAction::ActiveShortcut);
 633             }
 634             if (shortcutOption & KXMLGUIFactoryPrivate::SetDefaultShortcut)
 635                 ka->setShortcut(KShortcut(attribute.value()), KAction::DefaultShortcut);
 636             return;
 637         }
 638         propertyValue = KShortcut( attribute.value() );
 639     } else {
 640         propertyValue = QVariant( attribute.value() );
 641     }
 642     if (!action->setProperty( attrName.toLatin1(), propertyValue )) {
 643         kWarning() << "Error: Unknown action property " << attrName << " will be ignored!";
 644     }
 645 }
 646
 647 QDomDocument KXMLGUIFactoryPrivate::shortcutSchemeDoc(KXMLGUIClient *client)
 648 {
 649     // Get the name of the current shorcut scheme
 650     KConfigGroup cg = KGlobal::config()->group( "Shortcut Schemes" );
 651     QString schemeName = cg.readEntry("Current Scheme", "Default");
 652
 653     QDomDocument doc;
 654     if (schemeName != "Default")
 655     {
 656         // Find the document for the shortcut scheme using both current application path
 657         // and current xmlguiclient path but making a preference to app path
 658         QString schemeFileName = KStandardDirs::locateLocal("data",
 659             client->componentData().componentName() + '/' +
 660             client->componentData().componentName() + schemeName.toLower() + "shortcuts.rc" );
 661
 662         QFile schemeFile(schemeFileName);
 663         if (schemeFile.open(QIODevice::ReadOnly))
 664         {
 665 //             kDebug(260) << "Found shortcut scheme" << schemeFileName;
 666             doc.setContent(&schemeFile);
 667             schemeFile.close();
 668         }
 669     }
 670     return doc;
 671 }
 672
 673 void KXMLGUIFactoryPrivate::applyShortcutScheme(KXMLGUIClient *client, QDomDocument scheme)
 674 {
 675     static const QString &actionPropElementName = KGlobal::staticQString( "ActionProperties" );
 676
 677     KConfigGroup cg = KGlobal::config()->group( "Shortcut Schemes" );
 678     QString schemeName = cg.readEntry("Current Scheme", "Default");
 679
 680     //First clear all existing shortcuts
 681     if (schemeName != "Default") {
 682         foreach (QAction *action, client->actionCollection()->actions())
 683         {
 684             if (KAction *kaction = qobject_cast<KAction*>(action))
 685             {
 686                 kaction->setShortcut(KShortcut(), KAction::ActiveShortcut);
 687                 // We clear the default shortcut as well because the shortcut scheme will set its own defaults
 688                 kaction->setShortcut(KShortcut(), KAction::DefaultShortcut);
 689             }
 690             else
 691                 action->setProperty("shortcut", KShortcut());
 692         }
 693     } else {
 694         // apply saved default shortcuts
 695         foreach (QAction *action, client->actionCollection()->actions())
 696         {
 697             if (KAction *kaction = qobject_cast<KAction*>(action))
 698             {
 699                 QVariant savedDefaultShortcut = kaction->property("_k_DefaultShortcut");
 700                 if (savedDefaultShortcut.isValid())
 701                 {
 702                     KShortcut shortcut = savedDefaultShortcut.value<KShortcut>();
 703                     kaction->setShortcut(shortcut, KAction::ActiveShortcut);
 704                     kaction->setShortcut(shortcut, KAction::DefaultShortcut);
 705                     continue;
 706                 }
 707             }
 708             action->setProperty("shortcut", KShortcut());
 709         }
 710     }
 711
 712     if (scheme.isNull())
 713         return;
 714
 715     QDomElement docElement = scheme.documentElement();
 716     QDomElement actionPropElement = docElement.namedItem( actionPropElementName ).toElement();
 717
 718     //Check if we really have the shortcut configuration here
 719     if (!actionPropElement.isNull())
 720     {
 721         kDebug(260) << "Applying shortcut scheme for XMLGUI client" << client->componentData().componentName();
 722
 723         //Apply all shortcuts we have
 724         applyActionProperties(actionPropElement, KXMLGUIFactoryPrivate::SetDefaultShortcut);
 725     }
 726     else
 727         kDebug(260) << "Invalid shortcut scheme file";
 728 }
 729
 730 int KXMLGUIFactory::configureShortcuts(bool letterCutsOk , bool bSaveSettings )
 731 {
 732         KShortcutsDialog dlg(KShortcutsEditor::AllActions,
 733          letterCutsOk ? KShortcutsEditor::LetterShortcutsAllowed : KShortcutsEditor::LetterShortcutsDisallowed,
 734          qobject_cast<QWidget*>(parent()));
 735         foreach (KXMLGUIClient *client, d->m_clients)
 736         {
 737                 if(client && !client->xmlFile().isEmpty())
 738                         dlg.addCollection( client->actionCollection() );
 739         }
 740         return dlg.configure(bSaveSettings);
 741 }
 742
 743 QDomElement KXMLGUIFactory::actionPropertiesElement( QDomDocument& doc )
 744 {
 745         KConfigGroup cg = KGlobal::config()->group( "Shortcut Schemes" );
 746         QString schemeName = cg.readEntry("Current Scheme", "Default");
 747
 748         const QString tagActionProp = QLatin1String("ActionProperties");
 749         // first, lets see if we have existing properties
 750         QDomElement elem;
 751         QDomNode it = doc.documentElement().firstChild();
 752         for( ; !it.isNull(); it = it.nextSibling() ) {
 753                 QDomElement e = it.toElement();
 754                 if( ((e.tagName() == tagActionProp) || (e.tagName() == tagActionProp.toLower()))
 755                                 && (e.attribute("scheme", "Default") == schemeName) ) {
 756                         elem = e;
 757                         break;
 758                 }
 759         }
 760
 761         // if there was none, create one
 762         if( elem.isNull() ) {
 763                 elem = doc.createElement( tagActionProp );
 764                 elem.setAttribute( "scheme", schemeName );
 765                 doc.documentElement().appendChild( elem );
 766         }
 767         return elem;
 768 }
 769
 770 QDomElement KXMLGUIFactory::findActionByName( QDomElement& elem, const QString& sName, bool create )
 771 {
 772         static const QString& attrName = KGlobal::staticQString( "name" );
 773         static const QString& tagAction = KGlobal::staticQString( "Action" );
 774         for( QDomNode it = elem.firstChild(); !it.isNull(); it = it.nextSibling() ) {
 775                 QDomElement e = it.toElement();
 776                 if( e.attribute( attrName ) == sName )
 777                         return e;
 778         }
 779
 780         if( create ) {
 781                 QDomElement act_elem = elem.ownerDocument().createElement( tagAction );
 782                 act_elem.setAttribute( attrName, sName );
 783                 elem.appendChild( act_elem );
 784                 return act_elem;
 785         }
 786         return QDomElement();
 787 }
 788
 789 #include "kxmlguifactory.moc"
 790
 791 /* vim: et sw=4
 792  */