2 files changed, 14 insertions, 2 deletions
diff --git a/Swift/Controllers/HighlightManager.cpp b/Swift/Controllers/HighlightManager.cpp
index eac562f..ca0567e 100644
--- a/Swift/Controllers/HighlightManager.cpp
+++ b/Swift/Controllers/HighlightManager.cpp
@@ -71,61 +71,69 @@ std::string HighlightManager::rulesToString() const
 
 std::vector<HighlightRule> HighlightManager::getDefaultRules()
 {
 	std::vector<HighlightRule> rules;
 	HighlightRule r;
 	r.setMatchChat(true);
 	r.getAction().setPlaySound(true);
 	rules.push_back(r);
 	return rules;
 }
 
 HighlightRule HighlightManager::getRule(int index) const
 {
 	assert(index >= 0 && static_cast<size_t>(index) < rules_->getSize());
 	return rules_->getRule(static_cast<size_t>(index));
 }
 
 void HighlightManager::setRule(int index, const HighlightRule& rule)
 {
 	assert(index >= 0 && static_cast<size_t>(index) < rules_->getSize());
 	rules_->list_[static_cast<size_t>(index)] = rule;
 }
 
 void HighlightManager::insertRule(int index, const HighlightRule& rule)
 {
 	assert(index >= 0 && boost::numeric_cast<std::vector<std::string>::size_type>(index) <= rules_->getSize());
 	rules_->list_.insert(rules_->list_.begin() + index, rule);
 }
 
 void HighlightManager::removeRule(int index)
 {
 	assert(index >= 0 && boost::numeric_cast<std::vector<std::string>::size_type>(index) < rules_->getSize());
 	rules_->list_.erase(rules_->list_.begin() + index);
 }
 
+void HighlightManager::swapRules(const size_t first, const size_t second) {
+	assert(first < rules_->getSize());
+	assert(second < rules_->getSize());
+	const HighlightRule swap = rules_->getRule(first);
+	rules_->setRule(first, rules_->getRule(second));
+	rules_->setRule(second, swap);
+}
+
 void HighlightManager::storeSettings()
 {
 	storingSettings_ = true;	// don't reload settings while saving
 	settings_->storeSetting(SettingConstants::HIGHLIGHT_RULES, rulesToString());
 	storingSettings_ = false;
 }
 
 void HighlightManager::loadSettings()
 {
 	std::string rulesString = settings_->getSetting(SettingConstants::HIGHLIGHT_RULES);
 	std::stringstream stream;
 	stream << rulesString;
 	try {
 		boost::archive::text_iarchive archive(stream);
 		archive >> rules_->list_;
 	} catch (boost::archive::archive_exception&) {
 		rules_->list_ = getDefaultRules();
 	}
 }
 
 Highlighter* HighlightManager::createHighlighter()
 {
 	return new Highlighter(this);
 }
 
 }
diff --git a/Swift/Controllers/HighlightManager.h b/Swift/Controllers/HighlightManager.h
index 3da72eb..07a3fe3 100644
--- a/Swift/Controllers/HighlightManager.h
+++ b/Swift/Controllers/HighlightManager.h
@@ -1,71 +1,75 @@
 /*
  * Copyright (c) 2012 Maciej Niedzielski
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
  * Copyright (c) 2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <vector>
 #include <string>
 
 #include <Swiften/Base/boost_bsignals.h>
 #include <Swift/Controllers/HighlightRule.h>
 
 namespace Swift {
 
 	class SettingsProvider;
 	class Highlighter;
 
 	class HighlightManager {
 		public:
 
 			class HighlightRulesList {
 			public:
 				friend class HighlightManager;
 				size_t getSize() const { return list_.size(); }
 				const HighlightRule& getRule(const size_t index) const { return list_[index]; }
-				void addRule(const HighlightRule &rule) { list_.push_back(rule); }
-				void combineRules(const HighlightRulesList &rhs) {
+				void addRule(const HighlightRule& rule) { list_.push_back(rule); }
+				void combineRules(const HighlightRulesList& rhs) {
 					list_.insert(list_.end(), rhs.list_.begin(), rhs.list_.end());
 				}
+				void setRule(const size_t index, const HighlightRule& rule) {
+					list_[index] = rule;
+				}
 			private:
 				std::vector<HighlightRule> list_;
 			};
 
 			HighlightManager(SettingsProvider* settings);
 
 			Highlighter* createHighlighter();
 
 			boost::shared_ptr<const HighlightManager::HighlightRulesList> getRules() const { return rules_; }
 
 			HighlightRule getRule(int index) const;
 			void setRule(int index, const HighlightRule& rule);
 			void insertRule(int index, const HighlightRule& rule);
 			void removeRule(int index);
+			void swapRules(const size_t first, const size_t second);
 			void storeSettings();
 			void loadSettings();
 
 			boost::signal<void (const HighlightAction&)> onHighlight;
 
 		private:
 			void handleSettingChanged(const std::string& settingPath);
 
 			std::string rulesToString() const;
 			static std::vector<HighlightRule> getDefaultRules();
 
 			SettingsProvider* settings_;
 			bool storingSettings_;
 
 			boost::shared_ptr<HighlightManager::HighlightRulesList> rules_;
 	};
 
 	typedef boost::shared_ptr<const HighlightManager::HighlightRulesList> HighlightRulesListPtr;
 
 }