]> git.lyx.org Git - lyx.git/blobdiff - src/BufferParams.cpp
EmbeddedObjects.lyx, Math.lyx, UserGuide.lyx: Spanish translation updates by Ignacio
[lyx.git] / src / BufferParams.cpp
index 647206426e1ac1ef401fe0a6570c58b885170ad7..7aca376dbe0a3f3ecd4526b5d7683d5e6f65cc33 100644 (file)
@@ -4,10 +4,10 @@
  * Licence details can be found in the file COPYING.
  *
  * \author Alfredo Braunstein
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
  * \author Jean-Marc Lasgouttes
  * \author John Levon
- * \author André Pönitz
+ * \author André Pönitz
  * \author Martin Vermeer
  *
  * Full author contact details are available in file CREDITS.
@@ -1468,26 +1468,72 @@ void BufferParams::setDocumentClass(DocumentClass const * const tc) {
 }
 
 
+bool BufferParams::removeBadModules()
+{
+       // we'll write a new list of modules, since we can't just remove them,
+       // as that would invalidate our iterators
+       list<string> oldModules = getModules();
+       clearLayoutModules();
+
+       list<string> const & provmods = baseClass()->providedModules();
+       list<string> const & exclmods = baseClass()->excludedModules();
+       bool consistent = true; // set to false if we have to do anything
+
+       list<string>::const_iterator oit = oldModules.begin();
+       list<string>::const_iterator const oen = oldModules.end();
+       for (; oit != oen; ++oit) {
+               string const & modname = *oit;
+               // skip modules that the class provides
+               if (find(provmods.begin(), provmods.end(), modname) != provmods.end()) {
+                       LYXERR0("Module `" << modname << "' dropped because provided by document class.");
+                       consistent = false;
+                       continue;
+               }
+               // are we excluded by the document class?
+               if (find(exclmods.begin(), exclmods.end(), modname) != exclmods.end()) {
+                       LYXERR0("Module `" << modname << "' dropped because excluded by document class.");
+                       consistent = false;
+                       continue;
+               }
+               // determine whether some provided module excludes us or we exclude it
+               list<string>::const_iterator pit = provmods.begin();
+               list<string>::const_iterator const pen = provmods.end();
+               bool excluded = false;
+               for (; !excluded && pit != pen; ++pit) {
+                       if (!LyXModule::areCompatible(modname, *pit)) {
+                               LYXERR0("Module " << modname << 
+                                               " dropped becuase it conflicts with provided module `" << *pit << "'.");
+                               consistent = false;
+                               excluded = true;
+                       }
+               }
+               if (excluded)
+                       continue;
+               layoutModules_.push_back(modname);
+       }
+       return consistent;
+}
+
+
 void BufferParams::addDefaultModules()
 {
-               // add any default modules not already in use
+       // add any default modules not already in use
        list<string> const & mods = baseClass()->defaultModules();
        list<string>::const_iterator mit = mods.begin();
        list<string>::const_iterator men = mods.end();
 
-       // we want to add these to the front, but in the right order,
-       // so we collect them here first.
-       list<string> modulesToAdd;
+       // We want to insert the default modules at the beginning of
+       // the list, but also to insert them in the correct order.
+       // The obvious thing to do would be to collect them and then
+       // insert them, but that doesn't work because a later default
+       // module may require an earlier one, and then the test below
+       //     moduleCanBeAdded(modname)
+       // will fail. So we have to do it a more complicated way.
+       list<string>::iterator insertpos = layoutModules_.begin();
+       int numinserts = 0;
 
        for (; mit != men; mit++) {
                string const & modName = *mit;
-               // see if we're already in use
-               if (find(layoutModules_.begin(), layoutModules_.end(), modName) !=
-                   layoutModules_.end()) {
-                       LYXERR(Debug::TCLASS, "Default module `" << modName << 
-                                       "' not added because already used.");
-                       continue;
-               }
                // make sure the user hasn't removed it
                if (find(removedModules_.begin(), removedModules_.end(), modName) !=
                    removedModules_.end()) {
@@ -1496,55 +1542,90 @@ void BufferParams::addDefaultModules()
                        continue;
                }
 
-               // Now we want to check the list of selected modules to see if any of them
-               // excludes this one, or if we exclude one of them.
-               LyXModule * thismod = moduleList[modName];
-               if (!thismod) {
-                       LYXERR0("Adding default module " << modName << 
-                                       " even though it is unavailable.");
-                       modulesToAdd.push_back(modName);
+               if (!moduleCanBeAdded(modName)) {
+                       // FIXME This could be because it's already present, so we should
+                       // probably return something indicating that.
+                       LYXERR(Debug::TCLASS, "Default module `" << modName << 
+                                       "' could not be added.");
                        continue;
                }
+               LYXERR(Debug::TCLASS, "Default module `" << modName << "' added.");
+               layoutModules_.insert(insertpos, modName);
+               // now we reset insertpos
+               ++numinserts;
+               insertpos = layoutModules_.begin();
+               advance(insertpos, numinserts);
+       }
+}
 
-               bool foundit = false;
-               vector<string> const ourExcMods = thismod->getExcludedModules();
-               vector<string>::const_iterator const eit = ourExcMods.begin();
-               vector<string>::const_iterator const een = ourExcMods.end();
-
-               // so iterate over the selected modules...
-               LayoutModuleList::const_iterator lit = layoutModules_.begin();
-               LayoutModuleList::const_iterator const len = layoutModules_.end();
-               for (; lit != len; lit++) {
-                       LyXModule * lm = moduleList[*lit];
-                       if (!lm)
-                               continue;
-                       vector<string> const & exc = lm->getExcludedModules();
-                       // ...and see if this one excludes us.
-                       if (find(exc.begin(), exc.end(), modName) != exc.end()) {
-                               foundit = true;
-                               LYXERR(Debug::TCLASS, "Default module `" << modName << 
-                                               "' not added because excluded by loaded module `" << 
-                                               *lit << "'.");
-                               break;
-                       }
-                       if (find(eit, een, *lit) != een) {
-                               foundit = true;
-                               LYXERR(Debug::TCLASS, "Default module `" << modName << 
-                                               "' not added because it excludes loaded module `" << 
-                                               *lit << "'.");
-                               break;
+
+bool BufferParams::checkModuleConsistency() {
+       bool consistent = true;
+       // Perform a consistency check on the set of modules. We need to make
+       // sure that none of the modules exclude each other and that requires
+       // are satisfied.
+       list<string> oldModules = getModules();
+       clearLayoutModules();
+       list<string>::const_iterator oit = oldModules.begin();
+       list<string>::const_iterator oen = oldModules.end();
+       list<string> const & provmods = baseClass()->providedModules();
+       for (; oit != oen; ++oit) {
+               string const & modname = *oit;
+               bool excluded = false;
+               // Determine whether some prior module excludes us, or we exclude it
+               list<string>::const_iterator lit = layoutModules_.begin();
+               list<string>::const_iterator len = layoutModules_.end();
+               for (; !excluded && lit != len; ++lit) {
+                       if (!LyXModule::areCompatible(modname, *lit)) {
+                               consistent = false;
+                               LYXERR0("Module " << modname << 
+                                               " dropped because it is excluded by prior module " << *lit);
+                               excluded = true;
                        }
                }
 
-               if (!foundit) {
-                       LYXERR(Debug::TCLASS, "Default module `" << modName << "' added.");
-                       modulesToAdd.push_back(modName);
+               if (excluded)
+                       continue;
+
+               // determine whether some provided module or some prior module
+               // satisfies our requirements
+               LyXModule const * const oldmod = moduleList[modname];
+               if (!oldmod) {
+                       LYXERR0("Default module " << modname << 
+                                       " added although it is unavailable and can't check requirements.");
+                       continue;
+               }
+                       
+               vector<string> const & reqs = oldmod->getRequiredModules();
+               if (!reqs.empty()) {
+                       // we now set excluded to true, meaning that we haven't
+                       // yet found a required module.
+                       excluded = true;
+                       vector<string>::const_iterator rit  = reqs.begin();
+                       vector<string>::const_iterator ren = reqs.end();
+                       for (; rit != ren; ++rit) {
+                               string const reqmod = *rit;
+                               if (find(provmods.begin(), provmods.end(), reqmod) != 
+                                               provmods.end()) {
+                                       excluded = false;
+                                       break;
+                               }
+                               if (find(layoutModules_.begin(), layoutModules_.end(), reqmod) != 
+                                               layoutModules_.end()) {
+                                       excluded = false;
+                                       break;
+                               }
+                       }
+               }
+               if (excluded) {
+                       consistent = false;
+                       LYXERR0("Module " << modname << " dropped because requirements not met.");
+               } else {
+                       LYXERR(Debug::TCLASS, "Module " << modname << " passed consistency check.");
+                       layoutModules_.push_back(modname);
                }
        }
-
-       // OK, now we can add the default modules.
-       layoutModules_.insert(
-                       layoutModules_.begin(), modulesToAdd.begin(), modulesToAdd.end());
+       return consistent;
 }
 
 
@@ -1573,7 +1654,27 @@ bool BufferParams::setBaseClass(string const & classname)
        }
 
        pimpl_->baseClass_ = classname;
+       // the previous document class may have loaded some modules that the
+       // new one excludes, and the new class may provide, etc, some that
+       // conflict with ones that were already loaded. So we need to go 
+       // through the list and fix everything. I suppose there are various
+       // ways this could be done, but the following seems to work at the 
+       // moment. (Thanks to Philippe Charpentier for helping work out all 
+       // the bugs---rgh.)
+       // 
+       // first, we remove any modules the new document class itself provides,
+       // those it excludes, and those that conflict with ones it excludes.
+       // this has to be done first because, otherwise, a module we're about
+       // to remove could prevent a default module from being added.
+       removeBadModules();
+       // next, we add any default modules the new class provides.
        addDefaultModules();
+       // finally, we perform a general consistency check on the set of
+       // loaded modules.
+       checkModuleConsistency();
+       // FIXME removeBadModules() and checkModuleConsistency() both return
+       // a boolean indicating whether something had to be changed. It might
+       // be worth popping a message to the user if so.
 
        return true;
 }
@@ -1643,7 +1744,71 @@ void BufferParams::makeDocumentClass()
 }
 
 
-bool BufferParams::addLayoutModule(string const & modName) 
+bool BufferParams::moduleCanBeAdded(string const & modName) const
+{
+       // Is the module already present?
+       LayoutModuleList::const_iterator it = layoutModules_.begin();
+       LayoutModuleList::const_iterator end = layoutModules_.end();
+       for (; it != end; it++)
+               if (*it == modName) 
+                       return false;
+
+       LyXModule const * const lm = moduleList[modName];
+       if (!lm)
+               return true;
+
+       // Is this module explicitly excluded by the document class?
+       list<string>::const_iterator const exclmodstart = 
+                       baseClass()->excludedModules().begin();
+       list<string>::const_iterator const exclmodend = 
+                       baseClass()->excludedModules().end();
+       if (find(exclmodstart, exclmodend, modName) != exclmodend)
+               return false;
+
+       // Is this module already provided by the document class?
+       list<string>::const_iterator const provmodstart = 
+                       baseClass()->providedModules().begin();
+       list<string>::const_iterator const provmodend = 
+                       baseClass()->providedModules().end();
+       if (find(provmodstart, provmodend, modName) != provmodend)
+               return false;
+
+       // Check for conflicts with used modules
+       // first the provided modules...
+       list<string>::const_iterator provmodit = provmodstart;
+       for (; provmodit != provmodend; ++provmodit) {
+               if (!LyXModule::areCompatible(modName, *provmodit))
+                       return false;
+       }
+       // and then the selected modules
+       LayoutModuleList::const_iterator mit = getModules().begin();
+       LayoutModuleList::const_iterator const men = getModules().end();
+       for (; mit != men; ++mit)
+               if (!LyXModule::areCompatible(modName, *mit))
+                       return false;
+
+       // Check whether some required module is available
+       vector<string> const reqs = lm->getRequiredModules();
+       if (reqs.empty())
+               return true;
+
+       mit = getModules().begin(); // reset
+       vector<string>::const_iterator rit = reqs.begin();
+       vector<string>::const_iterator ren = reqs.end();
+       bool foundone = false;
+       for (; rit != ren; ++rit) {
+               if (find(mit, men, *rit) != men || 
+                   find(provmodstart, provmodend, *rit) != provmodend) {
+                       foundone = true;
+                       break;
+               }
+       }
+
+       return foundone;
+}
+
+
+bool BufferParams::addLayoutModule(string const & modName)
 {
        LayoutModuleList::const_iterator it = layoutModules_.begin();
        LayoutModuleList::const_iterator end = layoutModules_.end();