Index: src/Actions/BondAction/BondAddAction.cpp
===================================================================
--- src/Actions/BondAction/BondAddAction.cpp	(revision 2fcef36f8dcba275ab6b2280c2ac65fea1f5322a)
+++ src/Actions/BondAction/BondAddAction.cpp	(revision b9b49e727d9d3d89c559b4370e78e73dd898f45d)
@@ -57,22 +57,43 @@
 ActionState::ptr BondAddAction::performCall() {
   // check preconditions
-  if (World::getInstance().countSelectedAtoms() != 2) {
-    STATUS("Exactly two atoms must be selected for BondAction Add.");
+  World& world = World::getInstance();
+  if (world.countSelectedAtoms() <= 1) {
+    STATUS("There must be at least two atoms selected for BondAction Add.");
     return Action::failure;
   }
-  const std::vector<atom *> selected_atoms = World::getInstance().getSelectedAtoms();
-  if (selected_atoms[0]->IsBondedTo(WorldTime::getTime(), selected_atoms[1])) {
-    STATUS("There already is a bond in between the two selected atoms.");
+
+  bondPairIds_t bondPairIds;
+  for (World::AtomSelectionConstIterator firstiter = world.beginAtomSelection();
+      firstiter != world.endAtomSelection(); ++firstiter) {
+    for (World::AtomSelectionConstIterator seconditer = firstiter;
+        seconditer != world.endAtomSelection(); ++seconditer) {
+      if (firstiter == seconditer)
+        continue;
+      if (!(firstiter->second)->IsBondedTo(WorldTime::getTime(), seconditer->second))
+        bondPairIds.push_back(
+            std::make_pair((firstiter->second)->getId(), (seconditer->second)->getId()));
+    }
+  }
+  if (bondPairIds.empty()) {
+    STATUS("All bonds are already present.");
     return Action::failure;
   }
 
   // create undo
-  BondAddState *UndoState = new BondAddState(selected_atoms[0]->getId(), selected_atoms[1]->getId(), params);
+  BondAddState *UndoState = new BondAddState(bondPairIds, params);
 
   // execute action
-  selected_atoms[0]->addBond(WorldTime::getTime(), selected_atoms[1]);
-  ASSERT( selected_atoms[0]->IsBondedTo(WorldTime::getTime(), selected_atoms[1]),
+  for (bondPairIds_t::const_iterator iter = bondPairIds.begin();
+      iter != bondPairIds.end(); ++iter) {
+    atom *firstatom = world.getAtom(AtomById(iter->first));
+    atom *secondatom = world.getAtom(AtomById(iter->second));
+    ASSERT((firstatom != NULL) && (secondatom != NULL),
+        "BondAddAction::performCall() - at least one of the ids "
+        +toString(iter->first)+" or "+toString(iter->second)+" is not present.");
+    firstatom->addBond(WorldTime::getTime(), secondatom);
+    ASSERT( firstatom->IsBondedTo(WorldTime::getTime(), secondatom),
       "BondAddAction::performCall() - adding bond in between "
-      +toString(*selected_atoms[0])+" and "+toString(*selected_atoms[1])+" failed.");
+      +toString(*firstatom)+" and "+toString(*secondatom)+" failed.");
+  }
 
   return ActionState::ptr(UndoState);
@@ -83,14 +104,18 @@
 
   // check whether bond already existed
-  atom * const first = World::getInstance().getAtom(AtomById(state->firstId));
-  atom * const second = World::getInstance().getAtom(AtomById(state->secondId));
-  ASSERT((first != NULL) && (second != NULL),
-      "BondAddAction::performUndo() - at least one of the ids "
-      +toString(state->firstId)+" or "+toString(state->secondId)+" is not present.");
-  if (first->IsBondedTo(WorldTime::getTime(), second)) {
-    first->removeBond(WorldTime::getTime(), second);
-  } else {
-    ELOG(2, "There is no bond in between "+toString(state->firstId)
-        +" and "+toString(state->secondId)+".");
+  World& world = World::getInstance();
+  for (bondPairIds_t::const_iterator iter = state->bondPairIds.begin();
+      iter != state->bondPairIds.end(); ++iter) {
+    atom *firstatom = world.getAtom(AtomById(iter->first));
+    atom *secondatom = world.getAtom(AtomById(iter->second));
+    ASSERT((firstatom != NULL) && (secondatom != NULL),
+        "BondAddAction::performCall() - at least one of the ids "
+        +toString(iter->first)+" or "+toString(iter->second)+" is not present.");
+    if (firstatom->IsBondedTo(WorldTime::getTime(), secondatom)) {
+      firstatom->removeBond(WorldTime::getTime(), secondatom);
+    } else {
+      ELOG(2, "There is no bond in between "+toString(iter->first)
+          +" and "+toString(iter->second)+".");
+    }
   }
 
@@ -102,14 +127,18 @@
 
   // check whether bond already existed
-  atom * const first = World::getInstance().getAtom(AtomById(state->firstId));
-  atom * const second = World::getInstance().getAtom(AtomById(state->secondId));
-  ASSERT((first != NULL) && (second != NULL),
-      "BondAddAction::performRedo() - at least one of the ids "
-      +toString(state->firstId)+" or "+toString(state->secondId)+" is not present.");
-  if (!first->IsBondedTo(WorldTime::getTime(), second)) {
-    first->addBond(WorldTime::getTime(), second);
-  } else {
-    ELOG(2, "There is already a bond in between "+toString(state->firstId)
-        +" and "+toString(state->secondId)+".");
+  World& world = World::getInstance();
+  for (bondPairIds_t::const_iterator iter = state->bondPairIds.begin();
+      iter != state->bondPairIds.end(); ++iter) {
+    atom * const firstatom = world.getAtom(AtomById(iter->first));
+    atom * const secondatom = world.getAtom(AtomById(iter->second));
+    ASSERT((firstatom != NULL) && (secondatom != NULL),
+        "BondAddAction::performCall() - at least one of the ids "
+        +toString(iter->first)+" or "+toString(iter->second)+" is not present.");
+    if (!firstatom->IsBondedTo(WorldTime::getTime(), secondatom)) {
+      firstatom->addBond(WorldTime::getTime(), secondatom);
+    } else {
+      ELOG(2, "There is already a bond in between "+toString(iter->first)
+          +" and "+toString(iter->second)+".");
+    }
   }
 
Index: src/Actions/BondAction/BondAddAction.def
===================================================================
--- src/Actions/BondAction/BondAddAction.def	(revision 2fcef36f8dcba275ab6b2280c2ac65fea1f5322a)
+++ src/Actions/BondAction/BondAddAction.def	(revision b9b49e727d9d3d89c559b4370e78e73dd898f45d)
@@ -8,4 +8,8 @@
 // all includes and forward declarations necessary for non-integral types below
 #include "types.hpp"
+#include <vector>
+#include <utility>
+
+typedef std::vector<std::pair<atomId_t,atomId_t> > bondPairIds_t;
 
 // i.e. there is an integer with variable name Z that can be found in
@@ -20,6 +24,6 @@
 #undef paramvalids
 
-#define statetypes (atomId_t)(atomId_t)
-#define statereferences (firstId)(secondId)
+#define statetypes (bondPairIds_t)
+#define statereferences (bondPairIds)
 
 // some defines for all the names, you may use ACTION, STATE and PARAMS
@@ -28,7 +32,7 @@
 #define MENUPOSITION 1
 #define ACTIONNAME Add
-#define TOKEN "add-bond"
+#define TOKEN "add-bonds"
 
 // finally the information stored in the ActionTrait specialization
-#define DESCRIPTION "add bond in between two selected atoms"
+#define DESCRIPTION "add bonds in between any number of selected atoms"
 #undef SHORTFORM
Index: src/Actions/BondAction/BondRemoveAction.cpp
===================================================================
--- src/Actions/BondAction/BondRemoveAction.cpp	(revision 2fcef36f8dcba275ab6b2280c2ac65fea1f5322a)
+++ src/Actions/BondAction/BondRemoveAction.cpp	(revision b9b49e727d9d3d89c559b4370e78e73dd898f45d)
@@ -57,22 +57,43 @@
 ActionState::ptr BondRemoveAction::performCall() {
   // check preconditions
-  if (World::getInstance().countSelectedAtoms() != 2) {
-    STATUS("Exactly two atoms must be selected for BondAction Remove.");
+  World& world = World::getInstance();
+  if (world.countSelectedAtoms() <= 1) {
+    STATUS("At least two atoms must be selected for BondAction Remove.");
     return Action::failure;
   }
-  const std::vector<atom *> selected_atoms = World::getInstance().getSelectedAtoms();
-  if (!selected_atoms[0]->IsBondedTo(WorldTime::getTime(), selected_atoms[1])) {
-    STATUS("There is no bond in between the two selected atoms.");
+
+  bondPairIds_t bondPairIds;
+  for (World::AtomSelectionConstIterator firstiter = world.beginAtomSelection();
+      firstiter != world.endAtomSelection(); ++firstiter) {
+    for (World::AtomSelectionConstIterator seconditer = firstiter;
+        seconditer != world.endAtomSelection(); ++seconditer) {
+      if (firstiter == seconditer)
+        continue;
+      if ((firstiter->second)->IsBondedTo(WorldTime::getTime(), seconditer->second))
+        bondPairIds.push_back(
+            std::make_pair((firstiter->second)->getId(), (seconditer->second)->getId()));
+    }
+  }
+  if (bondPairIds.empty()) {
+    STATUS("No bonds are present.");
     return Action::failure;
   }
 
   // create undo
-  BondRemoveState *UndoState = new BondRemoveState(selected_atoms[0]->getId(), selected_atoms[1]->getId(), params);
+  BondRemoveState *UndoState = new BondRemoveState(bondPairIds, params);
 
   // execute action
-  selected_atoms[0]->removeBond(WorldTime::getTime(), selected_atoms[1]);
-  ASSERT( !selected_atoms[0]->IsBondedTo(WorldTime::getTime(), selected_atoms[1]),
-      "BondRemoveAction::performCall() - removing bond in between "
-      +toString(*selected_atoms[0])+" and "+toString(*selected_atoms[1])+" failed.");
+  for (bondPairIds_t::const_iterator iter = bondPairIds.begin();
+      iter != bondPairIds.end(); ++iter) {
+    atom *firstatom = world.getAtom(AtomById(iter->first));
+    atom *secondatom = world.getAtom(AtomById(iter->second));
+    ASSERT((firstatom != NULL) && (secondatom != NULL),
+        "BondAddAction::performCall() - at least one of the ids "
+        +toString(iter->first)+" or "+toString(iter->second)+" is not present.");
+    firstatom->removeBond(WorldTime::getTime(), secondatom);
+    ASSERT( !firstatom->IsBondedTo(WorldTime::getTime(), secondatom),
+      "BondAddAction::performCall() - adding bond in between "
+      +toString(*firstatom)+" and "+toString(*secondatom)+" failed.");
+  }
 
   return ActionState::ptr(UndoState);
@@ -82,15 +103,18 @@
   BondRemoveState *state = assert_cast<BondRemoveState*>(_state.get());
 
-  // check whether bond already existed
-  atom * const first = World::getInstance().getAtom(AtomById(state->firstId));
-  atom * const second = World::getInstance().getAtom(AtomById(state->secondId));
-  ASSERT((first != NULL) && (second != NULL),
-      "BondRemoveAction::performUndo() - at least one of the ids "
-      +toString(state->firstId)+" or "+toString(state->secondId)+" is not present.");
-  if (!first->IsBondedTo(WorldTime::getTime(), second)) {
-    first->addBond(WorldTime::getTime(), second);
-  } else {
-    ELOG(2, "There is already a bond in between "+toString(state->firstId)
-        +" and "+toString(state->secondId)+".");
+  World& world = World::getInstance();
+  for (bondPairIds_t::const_iterator iter = state->bondPairIds.begin();
+      iter != state->bondPairIds.end(); ++iter) {
+    atom * const firstatom = world.getAtom(AtomById(iter->first));
+    atom * const secondatom = world.getAtom(AtomById(iter->second));
+    ASSERT((firstatom != NULL) && (secondatom != NULL),
+        "BondAddAction::performCall() - at least one of the ids "
+        +toString(iter->first)+" or "+toString(iter->second)+" is not present.");
+    if (!firstatom->IsBondedTo(WorldTime::getTime(), secondatom)) {
+      firstatom->addBond(WorldTime::getTime(), secondatom);
+    } else {
+      ELOG(2, "There is already a bond in between "+toString(iter->first)
+          +" and "+toString(iter->second)+".");
+    }
   }
 
@@ -101,15 +125,18 @@
   BondRemoveState *state = assert_cast<BondRemoveState*>(_state.get());
 
-  // check whether bond already existed
-  atom * const first = World::getInstance().getAtom(AtomById(state->firstId));
-  atom * const second = World::getInstance().getAtom(AtomById(state->secondId));
-  ASSERT((first != NULL) && (second != NULL),
-      "BondRemoveAction::performRedo() - at least one of the ids "
-      +toString(state->firstId)+" or "+toString(state->secondId)+" is not present.");
-  if (first->IsBondedTo(WorldTime::getTime(), second)) {
-    first->removeBond(WorldTime::getTime(), second);
-  } else {
-    ELOG(2, "There is no bond in between "+toString(state->firstId)
-        +" and "+toString(state->secondId)+".");
+  World& world = World::getInstance();
+  for (bondPairIds_t::const_iterator iter = state->bondPairIds.begin();
+      iter != state->bondPairIds.end(); ++iter) {
+    atom *firstatom = world.getAtom(AtomById(iter->first));
+    atom *secondatom = world.getAtom(AtomById(iter->second));
+    ASSERT((firstatom != NULL) && (secondatom != NULL),
+        "BondAddAction::performCall() - at least one of the ids "
+        +toString(iter->first)+" or "+toString(iter->second)+" is not present.");
+    if (firstatom->IsBondedTo(WorldTime::getTime(), secondatom)) {
+      firstatom->removeBond(WorldTime::getTime(), secondatom);
+    } else {
+      ELOG(2, "There is no bond in between "+toString(iter->first)
+          +" and "+toString(iter->second)+".");
+    }
   }
 
Index: src/Actions/BondAction/BondRemoveAction.def
===================================================================
--- src/Actions/BondAction/BondRemoveAction.def	(revision 2fcef36f8dcba275ab6b2280c2ac65fea1f5322a)
+++ src/Actions/BondAction/BondRemoveAction.def	(revision b9b49e727d9d3d89c559b4370e78e73dd898f45d)
@@ -7,4 +7,9 @@
 
 // all includes and forward declarations necessary for non-integral types below
+#include "types.hpp"
+#include <vector>
+#include <utility>
+
+typedef std::vector<std::pair<atomId_t,atomId_t> > bondPairIds_t;
 
 // i.e. there is an integer with variable name Z that can be found in
@@ -19,6 +24,6 @@
 #undef paramvalids
 
-#define statetypes (atomId_t)(atomId_t)
-#define statereferences (firstId)(secondId)
+#define statetypes (bondPairIds_t)
+#define statereferences (bondPairIds)
 
 // some defines for all the names, you may use ACTION, STATE and PARAMS
@@ -27,7 +32,7 @@
 #define MENUPOSITION 2
 #define ACTIONNAME Remove
-#define TOKEN "remove-bond"
+#define TOKEN "remove-bonds"
 
 // finally the information stored in the ActionTrait specialization
-#define DESCRIPTION "remove the bond in between two selected atoms"
+#define DESCRIPTION "remove all  bonds present between selected atoms"
 #undef SHORTFORM
