Merge lp:~widelands-dev/widelands/bug-1343299 into lp:widelands

[GunChleoc]

Refactoring: removed CamelCase etc from function names.

[SirVer (sirver)]

Awesome! Code base is getting in ever better shape. Now formatting is the biggest remaining issue that needs solving.

review: Approve

=== modified file 'src/ai/ai_help_structs.cc'
--- src/ai/ai_help_structs.cc	2014-07-20 07:47:15 +0000
+++ src/ai/ai_help_structs.cc	2014-09-29 14:39:47 +0000
@@ -60,7 +60,7 @@
 	return true;
 }
 
-bool CheckStepRoadAI::reachabledest(Map& map, FCoords const dest) const {
+bool CheckStepRoadAI::reachable_dest(Map& map, FCoords const dest) const {
 	NodeCaps const caps = dest.field->nodecaps();
 
 	if (!(caps & movecaps_)) {

=== modified file 'src/ai/ai_help_structs.h'
--- src/ai/ai_help_structs.h	2014-09-10 08:55:04 +0000
+++ src/ai/ai_help_structs.h	2014-09-29 14:39:47 +0000
@@ -48,7 +48,7 @@
 	}
 
 	bool allowed(Map&, FCoords start, FCoords end, int32_t dir, CheckStep::StepId) const;
-	bool reachabledest(Map&, FCoords dest) const;
+	bool reachable_dest(Map&, FCoords dest) const;
 
 	Player* player_;
 	uint8_t movecaps_;

=== modified file 'src/ai/computer_player.cc'
--- src/ai/computer_player.cc	2014-09-10 13:03:40 +0000
+++ src/ai/computer_player.cc	2014-09-29 14:39:47 +0000
@@ -50,7 +50,7 @@
 EmptyAI::EmptyAIImpl EmptyAI::implementation;
 
 const ComputerPlayer::ImplementationVector &
-ComputerPlayer::getImplementations()
+ComputerPlayer::get_implementations()
 {
 	static std::vector<ComputerPlayer::Implementation const *> impls;
 
@@ -64,10 +64,10 @@
 	return impls;
 }
 
-const ComputerPlayer::Implementation * ComputerPlayer::getImplementation
+const ComputerPlayer::Implementation * ComputerPlayer::get_implementation
 	(const std::string & name)
 {
-	const ImplementationVector & vec = getImplementations();
+	const ImplementationVector & vec = get_implementations();
 
 	for (const ComputerPlayer::Implementation* implementation : vec) {
 		if (implementation->name == name) {

=== modified file 'src/ai/computer_player.h'
--- src/ai/computer_player.h	2014-09-14 11:31:58 +0000
+++ src/ai/computer_player.h	2014-09-29 14:39:47 +0000
@@ -48,7 +48,7 @@
 	/**
 	 * Interface to a concrete implementation, used to instantiate AIs.
 	 *
-	 * \see getImplementations()
+	 * \see get_implementations()
 	 */
 	struct Implementation {
 		std::string name;
@@ -61,12 +61,12 @@
 	/**
 	 * Get a list of available AI implementations.
 	 */
-	static const ImplementationVector & getImplementations();
+	static const ImplementationVector & get_implementations();
 
 	/**
 	 * Get the best matching implementation for this name.
 	 */
-	static const Implementation * getImplementation(const std::string & name);
+	static const Implementation * get_implementation(const std::string & name);
 
 private:
 	Widelands::Game & m_game;

=== modified file 'src/ai/defaultai.cc'
--- src/ai/defaultai.cc	2014-09-14 11:31:58 +0000
+++ src/ai/defaultai.cc	2014-09-29 14:39:47 +0000
@@ -658,10 +658,10 @@
 
 				if (v > 0 && dist > 0) {
 
-					field.military_capacity_ += militarysite->maxSoldierCapacity();
-					field.military_presence_ += militarysite->stationedSoldiers().size();
+					field.military_capacity_ += militarysite->max_soldier_capacity();
+					field.military_presence_ += militarysite->stationed_soldiers().size();
 
-					if (!militarysite->stationedSoldiers().empty()) {
+					if (!militarysite->stationed_soldiers().empty()) {
 						field.military_stationed_ += 1;
 					}
 
@@ -2216,7 +2216,7 @@
 	for (std::list<MilitarySiteObserver>::iterator it = militarysites.begin();
 	     it != militarysites.end();
 	     ++it)
-		if (it->site->stationedSoldiers().size() == 0)
+		if (it->site->stationed_soldiers().size() == 0)
 			unstationed_milit_buildings_ += 1;
 
 	// count militarysites in construction
@@ -2250,7 +2250,7 @@
 		// as long as it is > 1 - BUT take care that there is a warehouse in the
 		// same economy where the thrown out soldiers can go to.
 		if (ms->economy().warehouses().size()) {
-			uint32_t const j = ms->soldierCapacity();
+			uint32_t const j = ms->soldier_capacity();
 
 			if (MilitarySite::kPrefersRookies != ms->get_soldier_preference()) {
 				game().send_player_militarysite_set_soldier_preference(
@@ -2283,8 +2283,8 @@
 	} else {
 		// If an enemy is in sight and the number of stationed soldier is not
 		// at maximum - set it to maximum.
-		uint32_t const j = ms->maxSoldierCapacity();
-		uint32_t const k = ms->soldierCapacity();
+		uint32_t const j = ms->max_soldier_capacity();
+		uint32_t const k = ms->soldier_capacity();
 
 		if (j > k)
 			// game().send_player_change_soldier_capacity(*ms, j - k);
@@ -2696,11 +2696,11 @@
 					continue;
 				}
 
-				if (bld->canAttack()) {
+				if (bld->can_attack()) {
 
 					// any_attackable_building=true;
 
-					int32_t ta = player_->findAttackSoldiers(bld->base_flag());
+					int32_t ta = player_->find_attack_soldiers(bld->base_flag());
 
 					if (type_ == NORMAL)
 						ta = ta * 2 / 3;
@@ -2708,24 +2708,24 @@
 					if (ta < 1)
 						continue;
 
-					int32_t const tc = ta - bld->presentSoldiers().size();
+					int32_t const tc = ta - bld->present_soldiers().size();
 
-					if (bld->presentSoldiers().size() > 1)
-						defend_ready_enemies += bld->presentSoldiers().size() - 1;
+					if (bld->present_soldiers().size() > 1)
+						defend_ready_enemies += bld->present_soldiers().size() - 1;
 
 					if (tc > chance) {
 						target = bld;
 						chance = tc;
 						attackers = ta;
-						defenders = bld->presentSoldiers().size();
+						defenders = bld->present_soldiers().size();
 					}
 				}
 			} else if (upcast(Warehouse, wh, immovables.at(j).object)) {
 				if (!player_->is_hostile(wh->owner()))
 					continue;
 
-				if (wh->canAttack()) {
-					int32_t ta = player_->findAttackSoldiers(wh->base_flag());
+				if (wh->can_attack()) {
+					int32_t ta = player_->find_attack_soldiers(wh->base_flag());
 
 					if (ta < 1)
 						continue;

=== modified file 'src/base/md5.h'
--- src/base/md5.h	2014-09-14 11:31:58 +0000
+++ src/base/md5.h	2014-09-29 14:39:47 +0000
@@ -65,8 +65,8 @@
 /**
  * This class is responsible for creating a streaming md5 checksum.
  * You simply pass it the data using stream operations, and if you want
- * to read the checksum, first call FinishChecksum(), followed by
- * GetChecksum().
+ * to read the checksum, first call finish_checksum(), followed by
+ * get_checksum().
  *
  * Instances of this class can be copied.
  */
@@ -93,24 +93,24 @@
 	///
 	/// \param data data to compute chksum for
 	/// \param size size of data
-	void Data(const void * const newdata, const size_t size) {
+	void data(const void * const newdata, const size_t size) {
 		assert(can_handle_data);
 		md5_process_bytes(newdata, size, &ctx);
 	}
 
 	/// This function finishes the checksum calculation.
 	/// After this, no more data may be written to the checksum.
-	void FinishChecksum() {
+	void finish_checksum() {
 		assert(can_handle_data);
 		can_handle_data = 0;
 		md5_finish_ctx(&ctx, sum.data);
 	}
 
-	/// Retrieve the checksum. Note that \ref FinishChecksum must be called
+	/// Retrieve the checksum. Note that \ref finish_checksum must be called
 	/// before this function.
 	///
 	/// \return a pointer to an array of 16 bytes containing the checksum.
-	const Md5Checksum & GetChecksum() const {
+	const Md5Checksum & get_checksum() const {
 		assert(!can_handle_data);
 		return sum;
 	}

=== modified file 'src/chat/chat.h'
--- src/chat/chat.h	2014-07-16 07:44:33 +0000
+++ src/chat/chat.h	2014-09-29 14:39:47 +0000
@@ -62,14 +62,14 @@
 	virtual ~ChatProvider();
 
 	// Send the given chat message. The message may or may not
-	// appear in subsequent calls to \ref getMessages.
+	// appear in subsequent calls to \ref get_messages.
 	virtual void send(const std::string &) = 0;
 
 	// \return a (chronological) list of received chat messages.
 	// This list need not be stable or monotonic. In other words,
 	// subsequent calls to this functions may return a smaller or
 	// greater number of chat messages.
-	virtual const std::vector<ChatMessage>& getMessages() const = 0;
+	virtual const std::vector<ChatMessage>& get_messages() const = 0;
 
 	// reimplemented e.g. in internet_gaming to silence the chat if in game.
 	// TODO(sirver): this does not belong here. The receiver of the

=== modified file 'src/economy/cmd_call_economy_balance.cc'
--- src/economy/cmd_call_economy_balance.cc	2014-09-10 08:55:04 +0000
+++ src/economy/cmd_call_economy_balance.cc	2014-09-29 14:39:47 +0000
@@ -53,24 +53,24 @@
 /**
  * Read and write
  */
-void CmdCallEconomyBalance::Read
+void CmdCallEconomyBalance::read
 	(FileRead & fr, EditorGameBase & egbase, MapObjectLoader & mol)
 {
 	try {
-		uint16_t const packet_version = fr.Unsigned16();
+		uint16_t const packet_version = fr.unsigned_16();
 		if (packet_version == CURRENT_CMD_CALL_ECONOMY_VERSION) {
-			GameLogicCommand::Read(fr, egbase, mol);
-			uint32_t serial = fr.Unsigned32();
+			GameLogicCommand::read(fr, egbase, mol);
+			uint32_t serial = fr.unsigned_32();
 			if (serial)
 				m_flag = &mol.get<Flag>(serial);
-			m_timerid = fr.Unsigned32();
+			m_timerid = fr.unsigned_32();
 		} else if (packet_version == 1 || packet_version == 2) {
-			GameLogicCommand::Read(fr, egbase, mol);
-			uint8_t const player_number = fr.Unsigned8();
+			GameLogicCommand::read(fr, egbase, mol);
+			uint8_t const player_number = fr.unsigned_8();
 			if (Player * const player = egbase.get_player(player_number)) {
-				if (!fr.Unsigned8())
+				if (!fr.unsigned_8())
 					throw wexception("0 is not allowed here");
-				uint16_t const economy_number = fr.Unsigned16();
+				uint16_t const economy_number = fr.unsigned_16();
 				if (economy_number < player->get_nr_economies())
 					m_flag =
 						player->get_economy_by_number(economy_number)
@@ -80,7 +80,7 @@
 			} else
 				throw wexception("invalid player number %u", player_number);
 			if (packet_version >= 2)
-				m_timerid = fr.Unsigned32();
+				m_timerid = fr.unsigned_32();
 			else
 				m_timerid = 0;
 		} else
@@ -90,18 +90,18 @@
 		throw wexception("call economy balance: %s", e.what());
 	}
 }
-void CmdCallEconomyBalance::Write
+void CmdCallEconomyBalance::write
 	(FileWrite & fw, EditorGameBase & egbase, MapObjectSaver & mos)
 {
-	fw.Unsigned16(CURRENT_CMD_CALL_ECONOMY_VERSION);
+	fw.unsigned_16(CURRENT_CMD_CALL_ECONOMY_VERSION);
 
 	// Write Base Commands
-	GameLogicCommand::Write(fw, egbase, mos);
+	GameLogicCommand::write(fw, egbase, mos);
 	if (Flag * const flag = m_flag.get(egbase))
-		fw.Unsigned32(mos.get_object_file_index(*flag));
+		fw.unsigned_32(mos.get_object_file_index(*flag));
 	else
-		fw.Unsigned32(0);
-	fw.Unsigned32(m_timerid);
+		fw.unsigned_32(0);
+	fw.unsigned_32(m_timerid);
 }
 
 }

=== modified file 'src/economy/cmd_call_economy_balance.h'
--- src/economy/cmd_call_economy_balance.h	2014-09-10 08:55:04 +0000
+++ src/economy/cmd_call_economy_balance.h	2014-09-29 14:39:47 +0000
@@ -39,8 +39,8 @@
 
 	uint8_t id() const override {return QUEUE_CMD_CALL_ECONOMY_BALANCE;}
 
-	void Write(FileWrite &, EditorGameBase &, MapObjectSaver  &) override;
-	void Read (FileRead  &, EditorGameBase &, MapObjectLoader &) override;
+	void write(FileWrite &, EditorGameBase &, MapObjectSaver  &) override;
+	void read (FileRead  &, EditorGameBase &, MapObjectLoader &) override;
 
 private:
 	OPtr<Flag> m_flag;

=== modified file 'src/economy/economy.cc'
--- src/economy/economy.cc	2014-09-14 11:31:58 +0000
+++ src/economy/economy.cc	2014-09-29 14:39:47 +0000
@@ -718,9 +718,9 @@
 		// alerts, so add info to the sync stream here.
 		{
 			::StreamWrite & ss = game.syncstream();
-			ss.Unsigned8 (req.get_type  ());
-			ss.Unsigned8 (req.get_index ());
-			ss.Unsigned32(req.target    ().serial());
+			ss.unsigned_8 (req.get_type  ());
+			ss.unsigned_8 (req.get_index ());
+			ss.unsigned_32(req.target    ().serial());
 		}
 
 		int32_t cost; // estimated time in milliseconds to fulfill Request
@@ -1017,12 +1017,12 @@
 	// to avoid potential future problems caused by the m_supplies changing
 	// under us in some way.
 	::StreamWrite & ss = game.syncstream();
-	ss.Unsigned32(0x02decafa); // appears as facade02 in sync stream
-	ss.Unsigned32(assignments.size());
+	ss.unsigned_32(0x02decafa); // appears as facade02 in sync stream
+	ss.unsigned_32(assignments.size());
 
 	for (const std::pair<Supply *, Warehouse *>& temp_assignment : assignments) {
-		ss.Unsigned32(temp_assignment.first->get_position(game)->serial());
-		ss.Unsigned32(temp_assignment.second->serial());
+		ss.unsigned_32(temp_assignment.first->get_position(game)->serial());
+		ss.unsigned_32(temp_assignment.second->serial());
 
 		temp_assignment.first->send_to_storage(game, temp_assignment.second);
 	}

=== modified file 'src/economy/economy_data_packet.cc'
--- src/economy/economy_data_packet.cc	2014-09-10 16:57:31 +0000
+++ src/economy/economy_data_packet.cc	2014-09-29 14:39:47 +0000
@@ -31,20 +31,20 @@
 
 namespace Widelands {
 
-void EconomyDataPacket::Read(FileRead & fr)
+void EconomyDataPacket::read(FileRead & fr)
 {
-	uint16_t const version = fr.Unsigned16();
+	uint16_t const version = fr.unsigned_16();
 
 	try {
 		if (1 <= version && version <= CURRENT_ECONOMY_VERSION) {
 			if (2 <= version)
 				try {
 					const TribeDescr & tribe = m_eco->owner().tribe();
-					while (Time const last_modified = fr.Unsigned32()) {
-						char const * const type_name = fr.CString();
-						uint32_t const permanent = fr.Unsigned32();
+					while (Time const last_modified = fr.unsigned_32()) {
+						char const * const type_name = fr.c_string();
+						uint32_t const permanent = fr.unsigned_32();
 						if (version <= 2)
-							fr.Unsigned32();
+							fr.unsigned_32();
 						WareIndex i = tribe.ware_index(type_name);
 						if (i != INVALID_INDEX) {
 							if (tribe.get_ware_descr(i)->default_target_quantity() ==
@@ -91,7 +91,7 @@
 				} catch (const WException & e) {
 					throw GameDataError("target quantities: %s", e.what());
 				}
-			m_eco->m_request_timerid = fr.Unsigned32();
+			m_eco->m_request_timerid = fr.unsigned_32();
 		} else {
 			throw GameDataError("unknown version %u", version);
 		}
@@ -100,18 +100,18 @@
 	}
 }
 
-void EconomyDataPacket::Write(FileWrite & fw)
+void EconomyDataPacket::write(FileWrite & fw)
 {
-	fw.Unsigned16(CURRENT_ECONOMY_VERSION);
+	fw.unsigned_16(CURRENT_ECONOMY_VERSION);
 	const TribeDescr & tribe = m_eco->owner().tribe();
 	for (WareIndex i = tribe.get_nrwares(); i;) {
 		--i;
 		const Economy::TargetQuantity & tq =
 			m_eco->m_ware_target_quantities[i];
 		if (Time const last_modified = tq.last_modified) {
-			fw.Unsigned32(last_modified);
-			fw.CString(tribe.get_ware_descr(i)->name());
-			fw.Unsigned32(tq.permanent);
+			fw.unsigned_32(last_modified);
+			fw.c_string(tribe.get_ware_descr(i)->name());
+			fw.unsigned_32(tq.permanent);
 		}
 	}
 	for (WareIndex i = tribe.get_nrworkers(); i;) {
@@ -119,13 +119,13 @@
 		const Economy::TargetQuantity & tq =
 			m_eco->m_worker_target_quantities[i];
 		if (Time const last_modified = tq.last_modified) {
-			fw.Unsigned32(last_modified);
-			fw.CString(tribe.get_worker_descr(i)->name());
-			fw.Unsigned32(tq.permanent);
+			fw.unsigned_32(last_modified);
+			fw.c_string(tribe.get_worker_descr(i)->name());
+			fw.unsigned_32(tq.permanent);
 		}
 	}
-	fw.Unsigned32(0); //  terminator
-	fw.Unsigned32(m_eco->m_request_timerid);
+	fw.unsigned_32(0); //  terminator
+	fw.unsigned_32(m_eco->m_request_timerid);
 }
 
 }

=== modified file 'src/economy/economy_data_packet.h'
--- src/economy/economy_data_packet.h	2014-09-10 07:57:29 +0000
+++ src/economy/economy_data_packet.h	2014-09-29 14:39:47 +0000
@@ -33,8 +33,8 @@
 	public:
 		EconomyDataPacket(Economy * e) : m_eco(e) {}
 
-		void Read(FileRead &);
-		void Write(FileWrite &);
+		void read(FileRead &);
+		void write(FileWrite &);
 
 	private:
 		Economy * m_eco;

=== modified file 'src/economy/fleet.cc'
--- src/economy/fleet.cc	2014-09-10 08:55:04 +0000
+++ src/economy/fleet.cc	2014-09-29 14:39:47 +0000
@@ -692,22 +692,22 @@
 
 	Fleet & fleet = get<Fleet>();
 
-	uint32_t nrships = fr.Unsigned32();
+	uint32_t nrships = fr.unsigned_32();
 	m_ships.resize(nrships);
 	for (uint32_t i = 0; i < nrships; ++i)
-		m_ships[i] = fr.Unsigned32();
+		m_ships[i] = fr.unsigned_32();
 
-	uint32_t nrports = fr.Unsigned32();
+	uint32_t nrports = fr.unsigned_32();
 	m_ports.resize(nrports);
 	for (uint32_t i = 0; i < nrports; ++i)
-		m_ports[i] = fr.Unsigned32();
+		m_ports[i] = fr.unsigned_32();
 
 	if (version >= 2) {
-		fleet.m_act_pending = fr.Unsigned8();
+		fleet.m_act_pending = fr.unsigned_8();
 		if (version < 3)
 			fleet.m_act_pending = false;
 		if (version < 4)
-			fr.Unsigned32(); // m_roundrobin
+			fr.unsigned_32(); // m_roundrobin
 	}
 }
 
@@ -756,9 +756,9 @@
 
 	try {
 		// The header has been peeled away by the caller
-		uint8_t const version = fr.Unsigned8();
+		uint8_t const version = fr.unsigned_8();
 		if (1 <= version && version <= FLEET_SAVEGAME_VERSION) {
-			PlayerNumber owner_number = fr.Unsigned8();
+			PlayerNumber owner_number = fr.unsigned_8();
 			if (!owner_number || owner_number > egbase.map().get_nrplayers())
 				throw GameDataError
 					("owner number is %u but there are only %u players",
@@ -781,23 +781,23 @@
 
 void Fleet::save(EditorGameBase & egbase, MapObjectSaver & mos, FileWrite & fw)
 {
-	fw.Unsigned8(HeaderFleet);
-	fw.Unsigned8(FLEET_SAVEGAME_VERSION);
+	fw.unsigned_8(HeaderFleet);
+	fw.unsigned_8(FLEET_SAVEGAME_VERSION);
 
-	fw.Unsigned8(m_owner.player_number());
+	fw.unsigned_8(m_owner.player_number());
 
 	MapObject::save(egbase, mos, fw);
 
-	fw.Unsigned32(m_ships.size());
+	fw.unsigned_32(m_ships.size());
 	for (const Ship * temp_ship : m_ships) {
-		fw.Unsigned32(mos.get_object_file_index(*temp_ship));
+		fw.unsigned_32(mos.get_object_file_index(*temp_ship));
 	}
-	fw.Unsigned32(m_ports.size());
+	fw.unsigned_32(m_ports.size());
 	for (const PortDock * temp_port : m_ports) {
-		fw.Unsigned32(mos.get_object_file_index(*temp_port));
+		fw.unsigned_32(mos.get_object_file_index(*temp_port));
 	}
 
-	fw.Unsigned8(m_act_pending);
+	fw.unsigned_8(m_act_pending);
 }
 
 } // namespace Widelands

=== modified file 'src/economy/portdock.cc'
--- src/economy/portdock.cc	2014-09-10 10:18:46 +0000
+++ src/economy/portdock.cc	2014-09-29 14:39:47 +0000
@@ -478,29 +478,29 @@
 
 	PortDock & pd = get<PortDock>();
 
-	m_warehouse = fr.Unsigned32();
-	uint16_t nrdockpoints = fr.Unsigned16();
+	m_warehouse = fr.unsigned_32();
+	uint16_t nrdockpoints = fr.unsigned_16();
 
 	pd.m_dockpoints.resize(nrdockpoints);
 	for (uint16_t i = 0; i < nrdockpoints; ++i) {
-		pd.m_dockpoints[i] = ReadCoords32(&fr, egbase().map().extent());
+		pd.m_dockpoints[i] = read_coords_32(&fr, egbase().map().extent());
 		pd.set_position(egbase(), pd.m_dockpoints[i]);
 	}
 
 	if (version >= 2) {
-		pd.m_need_ship = fr.Unsigned8();
+		pd.m_need_ship = fr.unsigned_8();
 
-		m_waiting.resize(fr.Unsigned32());
+		m_waiting.resize(fr.unsigned_32());
 		for (ShippingItem::Loader& shipping_loader : m_waiting) {
 			shipping_loader.load(fr);
 		}
 
 		if (version >= 3) {
 			// All the other expedition specific stuff is saved in the warehouse.
-			if (fr.Unsigned8()) {  // Do we have an expedition?
+			if (fr.unsigned_8()) {  // Do we have an expedition?
 				pd.m_expedition_bootstrap.reset(new ExpeditionBootstrap(&pd));
 			}
-			pd.m_expedition_ready = (fr.Unsigned8() == 1) ? true : false;
+			pd.m_expedition_ready = (fr.unsigned_8() == 1) ? true : false;
 		} else {
 			pd.m_expedition_ready = false;
 		}
@@ -545,7 +545,7 @@
 	try {
 		// The header has been peeled away by the caller
 
-		uint8_t const version = fr.Unsigned8();
+		uint8_t const version = fr.unsigned_8();
 		if (1 <= version && version <= PORTDOCK_SAVEGAME_VERSION) {
 			loader->init(egbase, mol, *new PortDock(nullptr));
 			loader->load(fr, version);
@@ -560,27 +560,27 @@
 
 void PortDock::save(EditorGameBase & egbase, MapObjectSaver & mos, FileWrite & fw)
 {
-	fw.Unsigned8(HeaderPortDock);
-	fw.Unsigned8(PORTDOCK_SAVEGAME_VERSION);
+	fw.unsigned_8(HeaderPortDock);
+	fw.unsigned_8(PORTDOCK_SAVEGAME_VERSION);
 
 	PlayerImmovable::save(egbase, mos, fw);
 
-	fw.Unsigned32(mos.get_object_file_index(*m_warehouse));
-	fw.Unsigned16(m_dockpoints.size());
+	fw.unsigned_32(mos.get_object_file_index(*m_warehouse));
+	fw.unsigned_16(m_dockpoints.size());
 	for (const Coords& coords: m_dockpoints) {
-		WriteCoords32(&fw, coords);
+		write_coords_32(&fw, coords);
 	}
 
-	fw.Unsigned8(m_need_ship);
+	fw.unsigned_8(m_need_ship);
 
-	fw.Unsigned32(m_waiting.size());
+	fw.unsigned_32(m_waiting.size());
 	for (ShippingItem& shipping_item : m_waiting) {
 		shipping_item.save(egbase, mos, fw);
 	}
 
 	// Expedition specific stuff
-	fw.Unsigned8(m_expedition_bootstrap.get() != nullptr ? 1 : 0);
-	fw.Unsigned8(m_expedition_ready ? 1 : 0);
+	fw.unsigned_8(m_expedition_bootstrap.get() != nullptr ? 1 : 0);
+	fw.unsigned_8(m_expedition_ready ? 1 : 0);
 }
 
 } // namespace Widelands

=== modified file 'src/economy/request.cc'
--- src/economy/request.cc	2014-09-14 12:13:35 +0000
+++ src/economy/request.cc	2014-09-29 14:39:47 +0000
@@ -105,14 +105,14 @@
  * might have been initialized. We have to kill them and replace
  * them through the data in the file
  */
-void Request::Read
+void Request::read
 	(FileRead & fr, Game & game, MapObjectLoader & mol)
 {
 	try {
-		uint16_t const version = fr.Unsigned16();
+		uint16_t const version = fr.unsigned_16();
 		if (version == 6) {
 			const TribeDescr& tribe = m_target.owner().tribe();
-			char const* const type_name = fr.CString();
+			char const* const type_name = fr.c_string();
 			WareIndex const wai = tribe.ware_index(type_name);
 			if (wai != INVALID_INDEX) {
 				m_type = wwWARE;
@@ -123,32 +123,32 @@
 					m_type = wwWORKER;
 					m_index = woi;
 				} else {
-					throw wexception("Request::Read: unknown type '%s'.\n", type_name);
+					throw wexception("Request::read: unknown type '%s'.\n", type_name);
 				}
 			}
-			m_count             = fr.Unsigned32();
-			m_required_time     = fr.Unsigned32();
-			m_required_interval = fr.Unsigned32();
+			m_count             = fr.unsigned_32();
+			m_required_time     = fr.unsigned_32();
+			m_required_interval = fr.unsigned_32();
 
-			m_last_request_time = fr.Unsigned32();
+			m_last_request_time = fr.unsigned_32();
 
 			assert(m_transfers.empty());
 
-			uint16_t const nr_transfers = fr.Unsigned16();
+			uint16_t const nr_transfers = fr.unsigned_16();
 			for (uint16_t i = 0; i < nr_transfers; ++i)
 				try {
-					MapObject* obj = &mol.get<MapObject>(fr.Unsigned32());
+					MapObject* obj = &mol.get<MapObject>(fr.unsigned_32());
 					Transfer* transfer;
 
 					if (upcast(Worker, worker, obj)) {
 						transfer = worker->get_transfer();
 						if (m_type != wwWORKER || !worker->descr().can_act_as(m_index)) {
-							throw wexception("Request::Read: incompatible transfer type");
+							throw wexception("Request::read: incompatible transfer type");
 						}
 					} else if (upcast(WareInstance, ware, obj)) {
 						transfer = ware->get_transfer();
 						if (m_type != wwWARE || ware->descr_index() != m_index) {
-							throw wexception("Request::Read: incompatible transfer type");
+							throw wexception("Request::read: incompatible transfer type");
 						}
 					} else {
 						throw wexception("transfer target %u is neither ware nor worker", obj->serial());
@@ -164,7 +164,7 @@
 				} catch (const WException& e) {
 				   throw wexception("transfer %u: %s", i, e.what());
 				}
-			m_requirements.Read (fr, game, mol);
+			m_requirements.read (fr, game, mol);
 			if (!is_open() && m_economy)
 				m_economy->remove_request(*this);
 		} else
@@ -177,10 +177,10 @@
 /**
  * Write this request to a file
  */
-void Request::Write
+void Request::write
 	(FileWrite & fw, Game & game, MapObjectSaver & mos) const
 {
-	fw.Unsigned16(REQUEST_VERSION);
+	fw.unsigned_16(REQUEST_VERSION);
 
 	//  Target and econmy should be set. Same is true for callback stuff.
 
@@ -188,30 +188,30 @@
 	const TribeDescr & tribe = m_target.owner().tribe();
 	assert(m_type != wwWARE   || m_index < tribe.get_nrwares  ());
 	assert(m_type != wwWORKER || m_index < tribe.get_nrworkers());
-	fw.CString
+	fw.c_string
 		(m_type == wwWARE                        ?
 		 tribe.get_ware_descr  (m_index)->name() :
 		 tribe.get_worker_descr(m_index)->name());
 
-	fw.Unsigned32(m_count);
-
-	fw.Unsigned32(m_required_time);
-	fw.Unsigned32(m_required_interval);
-
-	fw.Unsigned32(m_last_request_time);
-
-	fw.Unsigned16(m_transfers.size()); //  Write number of current transfers.
+	fw.unsigned_32(m_count);
+
+	fw.unsigned_32(m_required_time);
+	fw.unsigned_32(m_required_interval);
+
+	fw.unsigned_32(m_last_request_time);
+
+	fw.unsigned_16(m_transfers.size()); //  Write number of current transfers.
 	for (uint32_t i = 0; i < m_transfers.size(); ++i) {
 		Transfer & trans = *m_transfers[i];
 		if (trans.m_ware) { //  write ware/worker
 			assert(mos.is_object_known(*trans.m_ware));
-			fw.Unsigned32(mos.get_object_file_index(*trans.m_ware));
+			fw.unsigned_32(mos.get_object_file_index(*trans.m_ware));
 		} else if (trans.m_worker) {
 			assert(mos.is_object_known(*trans.m_worker));
-			fw.Unsigned32(mos.get_object_file_index(*trans.m_worker));
+			fw.unsigned_32(mos.get_object_file_index(*trans.m_worker));
 		}
 	}
-	m_requirements.Write (fw, game, mos);
+	m_requirements.write (fw, game, mos);
 }
 
 /**
@@ -407,16 +407,16 @@
 	assert(is_open());
 
 	::StreamWrite & ss = game.syncstream();
-	ss.Unsigned32(0x01decafa); // appears as facade01 in sync stream
-	ss.Unsigned32(target().serial());
-	ss.Unsigned32(supp.get_position(game)->serial());
+	ss.unsigned_32(0x01decafa); // appears as facade01 in sync stream
+	ss.unsigned_32(target().serial());
+	ss.unsigned_32(supp.get_position(game)->serial());
 
 	Transfer * t;
 	if (get_type() == wwWORKER) {
 		//  Begin the transfer of a soldier or worker.
 		//  launch_worker() creates or starts the worker
 		Worker & s = supp.launch_worker(game, *this);
-		ss.Unsigned32(s.serial());
+		ss.unsigned_32(s.serial());
 		t = new Transfer(game, *this, s);
 	} else {
 		//  Begin the transfer of an ware. The ware itself is passive.
@@ -424,7 +424,7 @@
 		//  warehouse. Once it's on the flag, the flag code will decide what to
 		//  do with it.
 		WareInstance & ware = supp.launch_ware(game, *this);
-		ss.Unsigned32(ware.serial());
+		ss.unsigned_32(ware.serial());
 		t = new Transfer(game, *this, ware);
 	}
 

=== modified file 'src/economy/request.h'
--- src/economy/request.h	2014-09-14 12:13:35 +0000
+++ src/economy/request.h	2014-09-29 14:39:47 +0000
@@ -93,8 +93,8 @@
 
 	void start_transfer(Game &, Supply &);
 
-	void Read (FileRead  &, Game &, MapObjectLoader &);
-	void Write(FileWrite &, Game &, MapObjectSaver  &) const;
+	void read (FileRead  &, Game &, MapObjectLoader &);
+	void write(FileWrite &, Game &, MapObjectSaver  &) const;
 	Worker * get_transfer_worker();
 
 	//  callbacks for WareInstance/Worker code

=== modified file 'src/economy/road.cc'
--- src/economy/road.cc	2014-09-10 13:03:40 +0000
+++ src/economy/road.cc	2014-09-29 14:39:47 +0000
@@ -41,7 +41,7 @@
 	return g_road_descr;
 }
 
-bool Road::IsRoadDescr(MapObjectDescr const * const descr)
+bool Road::is_road_descr(MapObjectDescr const * const descr)
 {
 	return descr == &g_road_descr;
 }
@@ -480,7 +480,7 @@
 	assert(static_cast<uint32_t>(index) < path.get_nsteps() - 1);
 
 	path.truncate(index);
-	secondpath.starttrim(index);
+	secondpath.trim_start(index);
 
 	molog("splitting road: first part:\n");
 	for (const Coords& coords : path.get_coords()) {

=== modified file 'src/economy/road.h'
--- src/economy/road.h	2014-09-14 11:31:58 +0000
+++ src/economy/road.h	2014-09-29 14:39:47 +0000
@@ -63,7 +63,7 @@
 
 	const RoadDescr& descr() const;
 
-	static bool IsRoadDescr(MapObjectDescr const *);
+	static bool is_road_descr(MapObjectDescr const *);
 
 	enum FlagId {
 		FlagStart = 0,

=== modified file 'src/economy/route.cc'
--- src/economy/route.cc	2014-09-10 10:18:46 +0000
+++ src/economy/route.cc	2014-09-29 14:39:47 +0000
@@ -63,7 +63,7 @@
 /**
  * Remove the first count steps from the route.
 */
-void Route::starttrim(int32_t count)
+void Route::trim_start(int32_t count)
 {
 	assert(count < static_cast<int32_t>(m_route.size()));
 
@@ -91,10 +91,10 @@
 {
 	m_route.clear();
 
-	m_totalcost = fr.Signed32();
-	uint32_t nsteps = fr.Unsigned16();
+	m_totalcost = fr.signed_32();
+	uint32_t nsteps = fr.unsigned_16();
 	for (uint32_t step = 0; step < nsteps; ++step)
-		data.flags.push_back(fr.Unsigned32());
+		data.flags.push_back(fr.unsigned_32());
 }
 
 
@@ -120,8 +120,8 @@
 void Route::save
 	(FileWrite & fw, EditorGameBase & egbase, MapObjectSaver & mos)
 {
-	fw.Signed32(get_totalcost());
-	fw.Unsigned16(m_route.size());
+	fw.signed_32(get_totalcost());
+	fw.unsigned_16(m_route.size());
 	for
 		(std::vector<ObjectPointer>::size_type idx = 0;
 		 idx < m_route.size();
@@ -129,7 +129,7 @@
 	{
 		Flag & flag = get_flag(egbase, idx);
 		assert(mos.is_object_known(flag));
-		fw.Unsigned32(mos.get_object_file_index(flag));
+		fw.unsigned_32(mos.get_object_file_index(flag));
 	}
 }
 

=== modified file 'src/economy/route.h'
--- src/economy/route.h	2014-09-10 08:55:04 +0000
+++ src/economy/route.h	2014-09-29 14:39:47 +0000
@@ -50,7 +50,7 @@
 	int32_t get_nrsteps() const {return m_route.size() - 1;}
 	Flag & get_flag(EditorGameBase &, std::vector<Flag *>::size_type);
 
-	void starttrim(int32_t count);
+	void trim_start(int32_t count);
 	void truncate(int32_t count);
 
 	struct LoadData {

=== modified file 'src/economy/shippingitem.cc'
--- src/economy/shippingitem.cc	2014-09-10 08:55:04 +0000
+++ src/economy/shippingitem.cc	2014-09-29 14:39:47 +0000
@@ -167,9 +167,9 @@
 
 void ShippingItem::Loader::load(FileRead & fr)
 {
-	uint8_t version = fr.Unsigned8();
+	uint8_t version = fr.unsigned_8();
 	if (1 <= version && version <= SHIPPINGITEM_SAVEGAME_VERSION) {
-		m_serial = fr.Unsigned32();
+		m_serial = fr.unsigned_32();
 	} else
 		throw GameDataError("unknown ShippingItem version %u", version);
 }
@@ -184,8 +184,8 @@
 
 void ShippingItem::save(EditorGameBase & egbase, MapObjectSaver & mos, FileWrite & fw)
 {
-	fw.Unsigned8(SHIPPINGITEM_SAVEGAME_VERSION);
-	fw.Unsigned32(mos.get_object_file_index_or_zero(m_object.get(egbase)));
+	fw.unsigned_8(SHIPPINGITEM_SAVEGAME_VERSION);
+	fw.unsigned_32(mos.get_object_file_index_or_zero(m_object.get(egbase)));
 }
 
 } // namespace Widelands

=== modified file 'src/economy/transfer.cc'
--- src/economy/transfer.cc	2014-09-10 07:57:29 +0000
+++ src/economy/transfer.cc	2014-09-29 14:39:47 +0000
@@ -178,7 +178,7 @@
 	if (m_route.get_nrsteps() >= 1)
 		if (upcast(Road const, road, location))
 			if (&road->get_flag(Road::FlagEnd) == &m_route.get_flag(m_game, 1))
-				m_route.starttrim(1);
+				m_route.trim_start(1);
 
 	if (m_route.get_nrsteps() >= 1)
 		if (upcast(Road const, road, destination))
@@ -316,11 +316,11 @@
 
 void Transfer::read(FileRead & fr, Transfer::ReadData & rd)
 {
-	uint8_t version = fr.Unsigned8();
+	uint8_t version = fr.unsigned_8();
 	if (version != TRANSFER_SAVEGAME_VERSION)
 		throw wexception("unhandled/unknown transfer version %u", version);
 
-	rd.destination = fr.Unsigned32();
+	rd.destination = fr.unsigned_32();
 }
 
 void Transfer::read_pointers
@@ -332,8 +332,8 @@
 
 void Transfer::write(MapObjectSaver & mos, FileWrite & fw)
 {
-	fw.Unsigned8(TRANSFER_SAVEGAME_VERSION);
-	fw.Unsigned32(mos.get_object_file_index_or_zero(m_destination.get(m_game)));
+	fw.unsigned_8(TRANSFER_SAVEGAME_VERSION);
+	fw.unsigned_32(mos.get_object_file_index_or_zero(m_destination.get(m_game)));
 	// not saving route right now, will be recaculated anyway
 }
 

=== modified file 'src/economy/ware_instance.cc'
--- src/economy/ware_instance.cc	2014-09-10 10:18:46 +0000
+++ src/economy/ware_instance.cc	2014-09-29 14:39:47 +0000
@@ -557,9 +557,9 @@
 	MapObject::Loader::load(fr);
 
 	WareInstance & ware = get<WareInstance>();
-	m_location = fr.Unsigned32();
-	m_transfer_nextstep = fr.Unsigned32();
-	if (fr.Unsigned8()) {
+	m_location = fr.unsigned_32();
+	m_transfer_nextstep = fr.unsigned_32();
+	if (fr.unsigned_8()) {
 		ware.m_transfer =
 			new Transfer(ref_cast<Game, EditorGameBase>(egbase()), ware);
 		ware.m_transfer->read(fr, m_transfer);
@@ -598,21 +598,21 @@
 void WareInstance::save
 	(EditorGameBase & egbase, MapObjectSaver & mos, FileWrite & fw)
 {
-	fw.Unsigned8(HeaderWareInstance);
-	fw.Unsigned8(WAREINSTANCE_SAVEGAME_VERSION);
-	fw.CString(descr().tribe().name());
-	fw.CString(descr().name());
+	fw.unsigned_8(HeaderWareInstance);
+	fw.unsigned_8(WAREINSTANCE_SAVEGAME_VERSION);
+	fw.c_string(descr().tribe().name());
+	fw.c_string(descr().name());
 
 	MapObject::save(egbase, mos, fw);
 
-	fw.Unsigned32(mos.get_object_file_index_or_zero(m_location.get(egbase)));
-	fw.Unsigned32
+	fw.unsigned_32(mos.get_object_file_index_or_zero(m_location.get(egbase)));
+	fw.unsigned_32
 		(mos.get_object_file_index_or_zero(m_transfer_nextstep.get(egbase)));
 	if (m_transfer) {
-		fw.Unsigned8(1);
+		fw.unsigned_8(1);
 		m_transfer->write(mos, fw);
 	} else {
-		fw.Unsigned8(0);
+		fw.unsigned_8(0);
 	}
 }
 
@@ -620,13 +620,13 @@
 	(EditorGameBase & egbase, MapObjectLoader & mol, FileRead & fr)
 {
 	try {
-		uint8_t version = fr.Unsigned8();
+		uint8_t version = fr.unsigned_8();
 
 		if (version != WAREINSTANCE_SAVEGAME_VERSION)
 			throw wexception("unknown/unhandled version %i", version);
 
-		const std::string tribename = fr.CString();
-		const std::string warename = fr.CString();
+		const std::string tribename = fr.c_string();
+		const std::string warename = fr.c_string();
 
 		egbase.manually_load_tribe(tribename);
 

=== modified file 'src/economy/wares_queue.cc'
--- src/economy/wares_queue.cc	2014-09-14 12:13:35 +0000
+++ src/economy/wares_queue.cc	2014-09-29 14:39:47 +0000
@@ -235,47 +235,47 @@
  * Read and write
  */
 #define WARES_QUEUE_DATA_PACKET_VERSION 2
-void WaresQueue::Write(FileWrite & fw, Game & game, MapObjectSaver & mos)
+void WaresQueue::write(FileWrite & fw, Game & game, MapObjectSaver & mos)
 {
-	fw.Unsigned16(WARES_QUEUE_DATA_PACKET_VERSION);
+	fw.unsigned_16(WARES_QUEUE_DATA_PACKET_VERSION);
 
 	//  Owner and callback is not saved, but this should be obvious on load.
-	fw.CString
+	fw.c_string
 		(owner().tribe().get_ware_descr(m_ware)->name().c_str());
-	fw.Signed32(m_max_size);
-	fw.Signed32(m_max_fill);
-	fw.Signed32(m_filled);
-	fw.Signed32(m_consume_interval);
+	fw.signed_32(m_max_size);
+	fw.signed_32(m_max_fill);
+	fw.signed_32(m_filled);
+	fw.signed_32(m_consume_interval);
 	if (m_request) {
-		fw.Unsigned8(1);
-		m_request->Write(fw, game, mos);
+		fw.unsigned_8(1);
+		m_request->write(fw, game, mos);
 	} else
-		fw.Unsigned8(0);
+		fw.unsigned_8(0);
 }
 
 
-void WaresQueue::Read(FileRead & fr, Game & game, MapObjectLoader & mol)
+void WaresQueue::read(FileRead & fr, Game & game, MapObjectLoader & mol)
 {
-	uint16_t const packet_version = fr.Unsigned16();
+	uint16_t const packet_version = fr.unsigned_16();
 	try {
 		if (packet_version == WARES_QUEUE_DATA_PACKET_VERSION || packet_version == 1) {
 			delete m_request;
-			m_ware             = owner().tribe().ware_index(fr.CString  ());
-			m_max_size         =                            fr.Unsigned32();
+			m_ware             = owner().tribe().ware_index(fr.c_string  ());
+			m_max_size         =                            fr.unsigned_32();
 			if (packet_version == 1)
 				m_max_fill = m_max_size;
 			else
-				m_max_fill = fr.Signed32();
-			m_filled           =                            fr.Unsigned32();
-			m_consume_interval =                            fr.Unsigned32();
-			if                                             (fr.Unsigned8 ()) {
-				m_request =                          //  TODO(unknown): Change Request::Read
+				m_max_fill = fr.signed_32();
+			m_filled           =                            fr.unsigned_32();
+			m_consume_interval =                            fr.unsigned_32();
+			if                                             (fr.unsigned_8 ()) {
+				m_request =                          //  TODO(unknown): Change Request::read
 					new Request                       //  to a constructor.
 						(m_owner,
 						 0,
 						 WaresQueue::request_callback,
 						 wwWORKER);
-				m_request->Read(fr, game, mol);
+				m_request->read(fr, game, mol);
 			} else
 				m_request = nullptr;
 

=== modified file 'src/economy/wares_queue.h'
--- src/economy/wares_queue.h	2014-09-14 12:13:35 +0000
+++ src/economy/wares_queue.h	2014-09-29 14:39:47 +0000
@@ -67,8 +67,8 @@
 
 	Player & owner() const {return m_owner.owner();}
 
-	void Read (FileRead  &, Game &, MapObjectLoader &);
-	void Write(FileWrite &, Game &, MapObjectSaver  &);
+	void read (FileRead  &, Game &, MapObjectLoader &);
+	void write(FileWrite &, Game &, MapObjectSaver  &);
 
 private:
 	static void request_callback

=== modified file 'src/editor/editorinteractive.cc'
--- src/editor/editorinteractive.cc	2014-09-14 16:08:13 +0000
+++ src/editor/editorinteractive.cc	2014-09-29 14:39:47 +0000
@@ -244,7 +244,7 @@
 	m_realtime = WLApplication::get()->get_time();
 	frametime = m_realtime - lasttime;
 
-	egbase().get_game_time_pointer() += frametime;
+	egbase().get_gametime_pointer() += frametime;
 
 	g_gr->animate_maptextures(egbase().get_gametime());
 }

=== modified file 'src/editor/map_generator.cc'
--- src/editor/map_generator.cc	2014-09-14 11:31:58 +0000
+++ src/editor/map_generator.cc	2014-09-29 14:39:47 +0000
@@ -59,13 +59,13 @@
 	 MapGenAreaInfo::MapGenTerrainType const terrType)
 {
 	//  Figure out which bob area is due here...
-	size_t num = map_gen_info_->getNumLandResources();
+	size_t num = map_gen_info_->get_num_land_resources();
 	size_t found = num;
-	uint32_t sum_weight = map_gen_info_->getSumLandResourceWeight();
+	uint32_t sum_weight = map_gen_info_->get_sum_land_resource_weight();
 	uint32_t max_val = 0;
 	for (size_t ix = 0; ix < num; ++ix) {
 		uint32_t val = random_bobs[ix][fc.x + map_info_.w * fc.y];
-		val = (val / sum_weight) * map_gen_info_->getLandResource(ix).getWeight();
+		val = (val / sum_weight) * map_gen_info_->get_land_resource(ix).get_weight();
 		if (val >= max_val) {
 			found = ix;
 			max_val = val;
@@ -76,15 +76,15 @@
 
 	// Figure out if we really need to set a bob here...
 
-	const MapGenLandResource & landResource = map_gen_info_->getLandResource(found);
+	const MapGenLandResource & landResource = map_gen_info_->get_land_resource(found);
 
-	const MapGenBobCategory * bobCategory = landResource.getBobCategory(terrType);
+	const MapGenBobCategory * bobCategory = landResource.get_bob_category(terrType);
 
 	if (!bobCategory) //  no bobs defined here...
 		return;
 
-	uint32_t immovDens = landResource.getImmovableDensity();
-	uint32_t movDens   = landResource.getMoveableDensity();
+	uint32_t immovDens = landResource.get_immovable_density();
+	uint32_t movDens   = landResource.get_moveable_density();
 
 	immovDens *= max_val / 100;
 	movDens   *= max_val / 100;
@@ -136,7 +136,7 @@
 		uint8_t res_val = static_cast<uint8_t>(random_value / (kMaxElevation / max_amount));
 		res_val *= static_cast<uint8_t>(map_info_.resource_amount) + 1;
 		res_val /= 3;
-		if (Editor_Change_Resource_Tool_Callback(fc, map_, world, res_idx)) {
+		if (editor_change_resource_tool_callback(fc, map_, world, res_idx)) {
 			fc.field->set_resources(res_idx, res_val);
 			fc.field->set_starting_res_amount(res_val);
 		}
@@ -205,9 +205,9 @@
 	(double                      const elevation,
 	 Coords                      const c)
 {
-	int32_t const water_h  = map_gen_info_->getWaterShallowHeight();
-	int32_t const mount_h  = map_gen_info_->getMountainFootHeight();
-	int32_t const summit_h = map_gen_info_->getSummitHeight      ();
+	int32_t const water_h  = map_gen_info_->get_water_shallow_height();
+	int32_t const mount_h  = map_gen_info_->get_mountain_foot_height();
+	int32_t const summit_h = map_gen_info_->get_summit_height       ();
 
 	double const water_fac = map_info_.waterRatio;
 	double const land_fac  = map_info_.landRatio;
@@ -452,9 +452,9 @@
 	 MapGenAreaInfo::MapGenTerrainType & terrType)
 {
 	uint32_t       numLandAreas      =
-		map_gen_info_->getNumAreas(MapGenAreaInfo::atLand);
+		map_gen_info_->get_num_areas(MapGenAreaInfo::atLand);
 	uint32_t const numWasteLandAreas =
-		map_gen_info_->getNumAreas(MapGenAreaInfo::atWasteland);
+		map_gen_info_->get_num_areas(MapGenAreaInfo::atWasteland);
 
 	bool isDesert  = false;
 	bool isDesertOuter = false;
@@ -516,10 +516,10 @@
 			landAreaIndex = 0;
 		else if (numLandAreas == 2) {
 			uint32_t const weight1 =
-				map_gen_info_->getArea(MapGenAreaInfo::atLand, 0).getWeight();
+				map_gen_info_->get_area(MapGenAreaInfo::atLand, 0).get_weight();
 			uint32_t const weight2 =
-				map_gen_info_->getArea(MapGenAreaInfo::atLand, 1).getWeight();
-			uint32_t const sum     = map_gen_info_->getSumLandWeight();
+				map_gen_info_->get_area(MapGenAreaInfo::atLand, 1).get_weight();
+			uint32_t const sum     = map_gen_info_->get_sum_land_weight();
 			if
 				(weight1 * (random2[c0.x + map_info_.w * c0.y] / sum)
 				 >=
@@ -529,12 +529,12 @@
 				landAreaIndex = 1;
 		} else {
 			uint32_t const weight1 =
-				map_gen_info_->getArea(MapGenAreaInfo::atLand, 0).getWeight();
+				map_gen_info_->get_area(MapGenAreaInfo::atLand, 0).get_weight();
 			uint32_t const weight2 =
-				map_gen_info_->getArea(MapGenAreaInfo::atLand, 1).getWeight();
+				map_gen_info_->get_area(MapGenAreaInfo::atLand, 1).get_weight();
 			uint32_t const weight3 =
-				map_gen_info_->getArea(MapGenAreaInfo::atLand, 2).getWeight();
-			uint32_t const sum     = map_gen_info_->getSumLandWeight();
+				map_gen_info_->get_area(MapGenAreaInfo::atLand, 2).get_weight();
+			uint32_t const sum     = map_gen_info_->get_sum_land_weight();
 			uint32_t const randomX = (rand2 + rand3) / 2;
 			if
 				(weight1 * (rand2 / sum) > weight2 * (rand3   / sum) &&
@@ -557,14 +557,14 @@
 
 	//  see whether it is water
 
-	uint32_t const coast_h   = map_gen_info_->getLandCoastHeight();
+	uint32_t const coast_h   = map_gen_info_->get_land_coast_height();
 	if (h1 <= coast_h && h2 <= coast_h && h3 <= coast_h) { //  water or coast...
 		atp = MapGenAreaInfo::atLand;
 		ttp = MapGenAreaInfo::ttLandCoast;
 
-		uint32_t const ocean_h   = map_gen_info_->getWaterOceanHeight();
-		uint32_t const shelf_h   = map_gen_info_->getWaterShelfHeight();
-		uint32_t const shallow_h = map_gen_info_->getWaterShallowHeight();
+		uint32_t const ocean_h   = map_gen_info_->get_water_ocean_height();
+		uint32_t const shelf_h   = map_gen_info_->get_water_shelf_height();
+		uint32_t const shallow_h = map_gen_info_->get_water_shallow_height();
 
 		//  TODO(unknown): The heights can not be lower than water-Shallow --
 		//  there will never be an ocean yet
@@ -580,10 +580,10 @@
 			ttp = MapGenAreaInfo::ttWaterShallow;
 		}
 	} else { //  it is not water
-		uint32_t const upper_h = map_gen_info_->getLandUpperHeight   ();
-		uint32_t const foot_h  = map_gen_info_->getMountainFootHeight();
-		uint32_t const mount_h = map_gen_info_->getMountainHeight    ();
-		uint32_t const snow_h  = map_gen_info_->getSnowHeight        ();
+		uint32_t const upper_h = map_gen_info_->get_land_upper_height   ();
+		uint32_t const foot_h  = map_gen_info_->get_mountain_foot_height();
+		uint32_t const mount_h = map_gen_info_->get_mountain_height     ();
+		uint32_t const snow_h  = map_gen_info_->get_snow_height         ();
 		if        (h1 >= snow_h  && h2 >= snow_h  && h3 >= snow_h)  {
 			atp = MapGenAreaInfo::atMountains;
 			ttp = MapGenAreaInfo::ttMountainsSnow;
@@ -616,11 +616,11 @@
 
 	//  Figure out which terrain to use at this point in the map...
 	return
-		map_gen_info_->getArea(atp, usedLandIndex).getTerrain
+		map_gen_info_->get_area(atp, usedLandIndex).get_terrain
 			(ttp,
 			 rng.rand()
 			 %
-			 map_gen_info_->getArea(atp, usedLandIndex).getNumTerrains(ttp));
+			 map_gen_info_->get_area(atp, usedLandIndex).get_num_terrains(ttp));
 
 }
 
@@ -663,9 +663,9 @@
 
 	// for bobs
 	std::unique_ptr<std::unique_ptr<uint32_t[]> []> random_bobs
-		(new std::unique_ptr<uint32_t[]> [map_gen_info_->getNumLandResources()]);
+		(new std::unique_ptr<uint32_t[]> [map_gen_info_->get_num_land_resources()]);
 
-	for (size_t ix = 0; ix < map_gen_info_->getNumLandResources(); ++ix)
+	for (size_t ix = 0; ix < map_gen_info_->get_num_land_resources(); ++ix)
 		random_bobs[ix].reset
 			(generate_random_value_map(map_info_.w, map_info_.h, rng));
 
@@ -871,7 +871,7 @@
 ===============
 */
 
-int  UniqueRandomMapInfo::mapIdCharToNumber(char ch)
+int  UniqueRandomMapInfo::map_id_char_to_number(char ch)
 {
 	if ((ch == '0') || (ch == 'o') || (ch == 'O'))
 		return 22;
@@ -917,7 +917,7 @@
 Return value: The converted value as a character
 ===============
 */
-char UniqueRandomMapInfo::mapIdNumberToChar(int32_t const num)
+char UniqueRandomMapInfo::map_id_number_to_char(int32_t const num)
 {
 	if (num == 22)
 		return '0';
@@ -950,7 +950,7 @@
 ===============
 */
 
-bool UniqueRandomMapInfo::setFromIdString
+bool UniqueRandomMapInfo::set_from_id_string
 	(UniqueRandomMapInfo & mapInfo_out, const std::string & mapIdString)
 {
 	//  check string
@@ -967,7 +967,7 @@
 	int32_t nums[kMapIdDigits];
 
 	for (uint32_t ix = 0; ix < kMapIdDigits; ++ix) {
-		int const num = mapIdCharToNumber(mapIdString[ix + (ix / 4)]);
+		int const num = map_id_char_to_number(mapIdString[ix + (ix / 4)]);
 		if (num < 0)
 			return false;
 		nums[ix] = num;
@@ -1050,7 +1050,7 @@
              begin created (map specific info)
 ===============
 */
-void UniqueRandomMapInfo::generateIdString
+void UniqueRandomMapInfo::generate_id_string
 	(std::string & mapIdsString_out, const UniqueRandomMapInfo & mapInfo)
 {
 	//  Init
@@ -1070,7 +1070,7 @@
 		nums[ix] = 0;
 
 	// Generate world name hash
-	uint16_t nameHash = generateWorldNameHash(mapInfo.world_name);
+	uint16_t nameHash = generate_world_name_hash(mapInfo.world_name);
 
 	//  Convert map random number
 	nums [0] =  mapInfo.mapNumber        & 31;
@@ -1134,14 +1134,14 @@
 
 	//  translate it to ASCII
 	for (uint32_t ix = 0; ix < kMapIdDigits; ++ix) {
-		mapIdsString_out += mapIdNumberToChar(nums[ix]);
+		mapIdsString_out += map_id_number_to_char(nums[ix]);
 		if (ix % 4 == 3 && ix != kMapIdDigits - 1)
 			mapIdsString_out += "-";
 	}
 }
 
 
-uint16_t Widelands::UniqueRandomMapInfo::generateWorldNameHash
+uint16_t Widelands::UniqueRandomMapInfo::generate_world_name_hash
 	(const std::string & name)
 {
 	// This is only a simple digest algorithm. Thats enough for our purposes.

=== modified file 'src/editor/map_generator.h'
--- src/editor/map_generator.h	2014-09-10 10:18:46 +0000
+++ src/editor/map_generator.h	2014-09-29 14:39:47 +0000
@@ -63,15 +63,15 @@
 	bool          islandMode;     //  whether the world will be an island
 
 	//  other stuff
-	static bool setFromIdString
+	static bool set_from_id_string
 		(UniqueRandomMapInfo & mapInfo_out, const std::string & mapIdString);
-	static void generateIdString
+	static void generate_id_string
 		(std::string & mapIdsString_out, const UniqueRandomMapInfo & mapInfo);
 
 private:
-	static int  mapIdCharToNumber(char);
-	static char mapIdNumberToChar(int32_t);
-	static uint16_t generateWorldNameHash(const std::string &);
+	static int  map_id_char_to_number(char);
+	static char map_id_number_to_char(int32_t);
+	static uint16_t generate_world_name_hash(const std::string &);
 };
 
 

=== modified file 'src/editor/tools/editor_decrease_resources_tool.cc'
--- src/editor/tools/editor_decrease_resources_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_decrease_resources_tool.cc	2014-09-29 14:39:47 +0000
@@ -57,7 +57,7 @@
 		args.orgRes.push_back(mr.location().field->get_resources_amount());
 
 		if (res == args.cur_res &&
-		    Editor_Change_Resource_Tool_Callback(mr.location(), map, world, args.cur_res)) {
+		    editor_change_resource_tool_callback(mr.location(), map, world, args.cur_res)) {
 			//  Ok, we're doing something. First remove the current overlays.
 			std::string str =
 			    world.get_resource(res)->get_editor_pic

=== modified file 'src/editor/tools/editor_increase_resources_tool.cc'
--- src/editor/tools/editor_increase_resources_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_increase_resources_tool.cc	2014-09-29 14:39:47 +0000
@@ -46,7 +46,7 @@
 }  // namespace
 
 
-int32_t Editor_Change_Resource_Tool_Callback
+int32_t editor_change_resource_tool_callback
 	(const TCoords<Widelands::FCoords>& c, Widelands::Map& map,
 	 const Widelands::World& world, int32_t const curres)
 {
@@ -110,7 +110,7 @@
 		if
 		((res == args.cur_res || !mr.location().field->get_resources_amount())
 		        &&
-		        Editor_Change_Resource_Tool_Callback(mr.location(), map, world, args.cur_res))
+				  editor_change_resource_tool_callback(mr.location(), map, world, args.cur_res))
 		{
 			//  Ok, we're doing something. First remove the current overlays.
 			const Image* pic =

=== modified file 'src/editor/tools/editor_increase_resources_tool.h'
--- src/editor/tools/editor_increase_resources_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_increase_resources_tool.h	2014-09-29 14:39:47 +0000
@@ -72,7 +72,7 @@
 	Widelands::ResourceIndex m_cur_res;
 };
 
-int32_t Editor_Change_Resource_Tool_Callback
+int32_t editor_change_resource_tool_callback
 	(const Widelands::TCoords<Widelands::FCoords>& c, Widelands::Map& map,
 	 const Widelands::World& world, int32_t const curres);
 

=== modified file 'src/editor/tools/editor_make_infrastructure_tool.cc'
--- src/editor/tools/editor_make_infrastructure_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_make_infrastructure_tool.cc	2014-09-29 14:39:47 +0000
@@ -31,7 +31,7 @@
  * Callback function to calculate correct overlays
  */
 int32_t
-Editor_Make_Infrastructure_Tool_Callback
+editor_make_infrastructure_tool_callback
 	(const Widelands::TCoords<Widelands::FCoords>& c,
 	 Widelands::EditorGameBase& egbase,
 	 int32_t const player)

=== modified file 'src/editor/tools/editor_make_infrastructure_tool.h'
--- src/editor/tools/editor_make_infrastructure_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_make_infrastructure_tool.h	2014-09-29 14:39:47 +0000
@@ -53,7 +53,7 @@
 	UI::UniqueWindow::Registry m_registry;
 };
 
-int32_t Editor_Make_Infrastructure_Tool_Callback
+int32_t editor_make_infrastructure_tool_callback
 	(const Widelands::TCoords<Widelands::FCoords>& c,
 	 Widelands::EditorGameBase& egbase, int32_t const player);
 

=== modified file 'src/editor/tools/editor_set_port_space_tool.cc'
--- src/editor/tools/editor_set_port_space_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_port_space_tool.cc	2014-09-29 14:39:47 +0000
@@ -30,7 +30,7 @@
 using namespace Widelands;
 
 /// static callback function for overlay calculation
-int32_t Editor_Tool_Set_Port_Space_Callback
+int32_t editor_Tool_set_port_space_callback
 	(const Widelands::TCoords<Widelands::FCoords>& c, Map& map)
 {
 	NodeCaps const caps = c.field->nodecaps();
@@ -71,7 +71,7 @@
 		(map, Widelands::Area<Widelands::FCoords>(map.get_fcoords(center.node), args.sel_radius));
 	do {
 		//  check if field is valid
-		if (Editor_Tool_Set_Port_Space_Callback(mr.location(), map)) {
+		if (editor_Tool_set_port_space_callback(mr.location(), map)) {
 			map.set_port_space(mr.location(), true);
 			Area<FCoords> a(mr.location(), 0);
 			map.recalc_for_field_area(world, a);
@@ -106,7 +106,7 @@
 		(map, Widelands::Area<Widelands::FCoords>(map.get_fcoords(center.node), args.sel_radius));
 	do {
 		//  check if field is valid
-		if (Editor_Tool_Set_Port_Space_Callback(mr.location(), map)) {
+		if (editor_Tool_set_port_space_callback(mr.location(), map)) {
 			map.set_port_space(mr.location(), false);
 			Area<FCoords> a(mr.location(), 0);
 			map.recalc_for_field_area(world, a);

=== modified file 'src/editor/tools/editor_set_port_space_tool.h'
--- src/editor/tools/editor_set_port_space_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_port_space_tool.h	2014-09-29 14:39:47 +0000
@@ -67,7 +67,7 @@
 	char const * get_sel_impl() const override {return FSEL_ESPS_FILENAME;}
 };
 
-int32_t Editor_Tool_Set_Port_Space_Callback
+int32_t editor_Tool_set_port_space_callback
 	(const Widelands::TCoords<Widelands::FCoords>& c, Widelands::Map& map);
 
 #endif  // end of include guard: WL_EDITOR_TOOLS_EDITOR_SET_PORT_SPACE_TOOL_H

=== modified file 'src/editor/tools/editor_set_resources_tool.cc'
--- src/editor/tools/editor_set_resources_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_resources_tool.cc	2014-09-29 14:39:47 +0000
@@ -55,7 +55,7 @@
 		args.orgResT.push_back(res);
 		args.orgRes.push_back(mr.location().field->get_resources_amount());
 
-		if (Editor_Change_Resource_Tool_Callback(mr.location(), map, world, args.cur_res)) {
+		if (editor_change_resource_tool_callback(mr.location(), map, world, args.cur_res)) {
 			//  Ok, we're doing something. First remove the current overlays.
 			const Image* pic = g_gr->images().get
 				(world.get_resource(res)->get_editor_pic (mr.location().field->get_resources_amount()));

=== modified file 'src/editor/tools/editor_set_starting_pos_tool.cc'
--- src/editor/tools/editor_set_starting_pos_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_starting_pos_tool.cc	2014-09-29 14:39:47 +0000
@@ -32,7 +32,7 @@
 /*
  * static callback function for overlay calculation
  */
-int32_t Editor_Tool_Set_Starting_Pos_Callback
+int32_t editor_tool_set_starting_pos_callback
 	(const Widelands::TCoords<Widelands::FCoords>& c, Widelands::Map& map)
 {
 	// Area around already placed players
@@ -88,7 +88,7 @@
 		const Image* pic = g_gr->images().get(picname);
 
 		//  check if field is valid
-		if (Editor_Tool_Set_Starting_Pos_Callback(map.get_fcoords(center.node), map)) {
+		if (editor_tool_set_starting_pos_callback(map.get_fcoords(center.node), map)) {
 			OverlayManager & overlay_manager = map.overlay_manager();
 			//  remove old overlay if any
 			overlay_manager.remove_overlay(old_sp, pic);

=== modified file 'src/editor/tools/editor_set_starting_pos_tool.h'
--- src/editor/tools/editor_set_starting_pos_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_starting_pos_tool.h	2014-09-29 14:39:47 +0000
@@ -51,7 +51,7 @@
 	char const * m_current_sel_pic;
 };
 
-int32_t Editor_Tool_Set_Starting_Pos_Callback
+int32_t editor_tool_set_starting_pos_callback
 	(const Widelands::TCoords<Widelands::FCoords>& c, Widelands::Map& map);
 
 #endif  // end of include guard: WL_EDITOR_TOOLS_EDITOR_SET_STARTING_POS_TOOL_H

=== modified file 'src/editor/ui_menus/editor_main_menu_load_map.cc'
--- src/editor/ui_menus/editor_main_menu_load_map.cc	2014-09-23 09:26:48 +0000
+++ src/editor/ui_menus/editor_main_menu_load_map.cc	2014-09-29 14:39:47 +0000
@@ -138,7 +138,7 @@
 void MainMenuLoadMap::clicked_ok() {
 	const char * const filename(m_ls->get_selected());
 
-	if (g_fs->IsDirectory(filename) && !WidelandsMapLoader::is_widelands_map(filename)) {
+	if (g_fs->is_directory(filename) && !WidelandsMapLoader::is_widelands_map(filename)) {
 		m_curdir = filename;
 		m_ls->clear();
 		m_mapfiles.clear();
@@ -157,7 +157,7 @@
 
 	m_ok_btn->set_enabled(true);
 
-	if (!g_fs->IsDirectory(name) || WidelandsMapLoader::is_widelands_map(name)) {
+	if (!g_fs->is_directory(name) || WidelandsMapLoader::is_widelands_map(name)) {
 		Widelands::Map map;
 		{
 			std::unique_ptr<Widelands::MapLoader> map_loader = map.get_correct_loader(name);
@@ -196,7 +196,7 @@
  */
 void MainMenuLoadMap::fill_list() {
 	//  Fill it with all files we find.
-	m_mapfiles = g_fs->ListDirectory(m_curdir);
+	m_mapfiles = g_fs->list_directory(m_curdir);
 
 	//  First, we add all directories. We manually add the parent directory.
 	if (m_curdir != m_basedir) {
@@ -222,13 +222,13 @@
 	{
 		const char * const name = pname->c_str();
 		if
-			(strcmp(FileSystem::FS_Filename(name), ".")    &&
-			 strcmp(FileSystem::FS_Filename(name), "..")   &&
-			 g_fs->IsDirectory(name)                       &&
+			(strcmp(FileSystem::fs_filename(name), ".")    &&
+			 strcmp(FileSystem::fs_filename(name), "..")   &&
+			 g_fs->is_directory(name)                       &&
 			 !WidelandsMapLoader::is_widelands_map(name))
 
 		m_ls->add
-			(FileSystem::FS_Filename(name),
+			(FileSystem::fs_filename(name),
 			 name,
 			 g_gr->images().get("pics/ls_dir.png"));
 	}
@@ -246,7 +246,7 @@
 			try {
 				map_loader->preload_map(true);
 				m_ls->add
-					(FileSystem::FS_Filename(name),
+					(FileSystem::fs_filename(name),
 					 name,
 					 g_gr->images().get
 						 (dynamic_cast<WidelandsMapLoader*>(map_loader.get())

=== modified file 'src/editor/ui_menus/editor_main_menu_map_options.cc'
--- src/editor/ui_menus/editor_main_menu_map_options.cc	2014-09-10 14:48:40 +0000
+++ src/editor/ui_menus/editor_main_menu_map_options.cc	2014-09-29 14:39:47 +0000
@@ -116,8 +116,8 @@
 	char buf[200];
 	sprintf(buf, "%ix%i", map.get_width(), map.get_height());
 	m_size->set_text(buf);
-	m_author->setText(map.get_author());
-	m_name  ->setText(map.get_name());
+	m_author->set_text(map.get_author());
+	m_name  ->set_text(map.get_name());
 	sprintf(buf, "%i", map.get_nrplayers());
 	m_nrplayers->set_text(buf);
 	m_descr ->set_text(map.get_description());

=== modified file 'src/editor/ui_menus/editor_main_menu_random_map.cc'
--- src/editor/ui_menus/editor_main_menu_random_map.cc	2014-09-14 12:13:35 +0000
+++ src/editor/ui_menus/editor_main_menu_random_map.cc	2014-09-29 14:39:47 +0000
@@ -90,7 +90,7 @@
 	m_mapNumber = rng.rand();
 	snprintf
 		(buffer, sizeof(buffer), "%u", static_cast<unsigned int>(m_mapNumber));
-	m_nrEditbox->setText(buffer);
+	m_nrEditbox->set_text(buffer);
 	posy += height + spacing + spacing + spacing;
 
 
@@ -297,7 +297,7 @@
 			 posx, posy,
 			 width, 20,
 			 g_gr->images().get("pics/but1.png"));
-	m_idEditbox->setText("abcd-efgh-ijkl-mnop");
+	m_idEditbox->set_text("abcd-efgh-ijkl-mnop");
 	m_idEditbox->changed.connect
 		(boost::bind(&MainMenuNewRandomMap::id_edit_box_changed, this));
 	posy += height + spacing + spacing + spacing;
@@ -499,12 +499,12 @@
 
 	std::string str = m_idEditbox->text();
 
-	if (!UniqueRandomMapInfo::setFromIdString(mapInfo, str))
+	if (!UniqueRandomMapInfo::set_from_id_string(mapInfo, str))
 		m_goButton->set_enabled(false);
 	else {
 		std::stringstream sstrm;
 		sstrm << mapInfo.mapNumber;
-		m_nrEditbox->setText(sstrm.str());
+		m_nrEditbox->set_text(sstrm.str());
 
 		m_h = 0;
 		for (uint32_t ix = 0; ix < NUMBER_OF_MAP_DIMENSIONS; ++ix)
@@ -545,9 +545,9 @@
 			set_map_info(mapInfo);
 
 			std::string idStr;
-			Widelands::UniqueRandomMapInfo::generateIdString(idStr, mapInfo);
+			Widelands::UniqueRandomMapInfo::generate_id_string(idStr, mapInfo);
 
-			m_idEditbox->setText(idStr);
+			m_idEditbox->set_text(idStr);
 
 			m_goButton->set_enabled(true);
 		} else

=== modified file 'src/editor/ui_menus/editor_main_menu_save_map.cc'
--- src/editor/ui_menus/editor_main_menu_save_map.cc	2014-09-23 09:26:48 +0000
+++ src/editor/ui_menus/editor_main_menu_save_map.cc	2014-09-29 14:39:47 +0000
@@ -73,7 +73,7 @@
 			 posx, posy + get_inner_h() - spacing - offsy - 60 + 3,
 			 get_inner_w() / 2 - spacing, 20,
 			 g_gr->images().get("pics/but1.png"));
-	m_editbox->setText(parent.egbase().map().get_name());
+	m_editbox->set_text(parent.egbase().map().get_name());
 	m_editbox->changed.connect(boost::bind(&MainMenuSaveMap::edit_box_changed, this));
 
 	posx = get_inner_w() / 2 + spacing;
@@ -164,11 +164,11 @@
 		filename = m_ls->get_selected();
 
 	if
-		(g_fs->IsDirectory(filename.c_str())
+		(g_fs->is_directory(filename.c_str())
 		 &&
 		 !Widelands::WidelandsMapLoader::is_widelands_map(filename))
 	{
-		m_curdir = g_fs->FS_CanonicalizeName(filename);
+		m_curdir = g_fs->canonicalize_name(filename);
 		m_ls->clear();
 		m_mapfiles.clear();
 		fill_list();
@@ -200,12 +200,12 @@
 void MainMenuSaveMap::clicked_make_directory() {
 	MainMenuSaveMapMakeDirectory md(this, _("unnamed"));
 	if (md.run()) {
-		g_fs->EnsureDirectoryExists(m_basedir);
+		g_fs->ensure_directory_exists(m_basedir);
 		//  create directory
 		std::string fullname = m_curdir;
 		fullname            += "/";
 		fullname            += md.get_dirname();
-		g_fs->MakeDirectory(fullname);
+		g_fs->make_directory(fullname);
 		m_ls->clear();
 		m_mapfiles.clear();
 		fill_list();
@@ -226,7 +226,7 @@
 			ml->preload_map(true); // This has worked before, no problem
 		}
 
-		m_editbox->setText(FileSystem::FS_Filename(name));
+		m_editbox->set_text(FileSystem::fs_filename(name));
 
 		m_name  ->set_text(map.get_name       ());
 		m_author->set_text(map.get_author     ());
@@ -239,11 +239,11 @@
 		sprintf(buf, "%ix%i", map.get_width(), map.get_height());
 		m_size->set_text(buf);
 	} else {
-		m_name     ->set_text(FileSystem::FS_Filename(name));
+		m_name     ->set_text(FileSystem::fs_filename(name));
 		m_author   ->set_text("");
 		m_nrplayers->set_text("");
 		m_size     ->set_text("");
-		if (g_fs->IsDirectory(name)) {
+		if (g_fs->is_directory(name)) {
 			std::string dir_string =
 				(boost::format("\\<%s\\>") % _("directory")).str();
 			m_descr    ->set_text(dir_string);
@@ -263,7 +263,7 @@
 void MainMenuSaveMap::double_clicked_item(uint32_t) {
 	const char * const name = m_ls->get_selected();
 
-	if (g_fs->IsDirectory(name) && !Widelands::WidelandsMapLoader::is_widelands_map(name)) {
+	if (g_fs->is_directory(name) && !Widelands::WidelandsMapLoader::is_widelands_map(name)) {
 		m_curdir = name;
 		m_ls->clear();
 		m_mapfiles.clear();
@@ -277,7 +277,7 @@
  */
 void MainMenuSaveMap::fill_list() {
 	// Fill it with all files we find.
-	m_mapfiles = g_fs->ListDirectory(m_curdir);
+	m_mapfiles = g_fs->list_directory(m_curdir);
 
 	// First, we add all directories. We manually add the parent directory
 	if (m_curdir != m_basedir) {
@@ -303,13 +303,13 @@
 	{
 		const char * const name = pname->c_str();
 		if
-			(strcmp(FileSystem::FS_Filename(name), ".")    &&
-			 strcmp(FileSystem::FS_Filename(name), "..")   &&
-			 g_fs->IsDirectory(name)                       &&
+			(strcmp(FileSystem::fs_filename(name), ".")    &&
+			 strcmp(FileSystem::fs_filename(name), "..")   &&
+			 g_fs->is_directory(name)                       &&
 			 !Widelands::WidelandsMapLoader::is_widelands_map(name))
 
 		m_ls->add
-			(FileSystem::FS_Filename(name),
+			(FileSystem::fs_filename(name),
 			 name,
 			 g_gr->images().get("pics/ls_dir.png"));
 	}
@@ -329,7 +329,7 @@
 			try {
 				wml->preload_map(true);
 				m_ls->add
-					(FileSystem::FS_Filename(name),
+					(FileSystem::fs_filename(name),
 					 name,
 					 g_gr->images().get("pics/ls_wlmap.png"));
 			} catch (const WException &) {} //  we simply skip illegal entries
@@ -355,7 +355,7 @@
  */
 bool MainMenuSaveMap::save_map(std::string filename, bool binary) {
 	//  Make sure that the base directory exists.
-	g_fs->EnsureDirectoryExists(m_basedir);
+	g_fs->ensure_directory_exists(m_basedir);
 
 	//  OK, first check if the extension matches (ignoring case).
 	bool assign_extension = true;
@@ -375,20 +375,20 @@
 	complete_filename            += filename;
 
 	//  Check if file exists. If so, show a warning.
-	if (g_fs->FileExists(complete_filename)) {
+	if (g_fs->file_exists(complete_filename)) {
 		std::string s =
 			(boost::format(_("A file with the name ‘%s’ already exists. Overwrite?"))
-				% FileSystem::FS_Filename(filename.c_str())).str();
+				% FileSystem::fs_filename(filename.c_str())).str();
 		UI::WLMessageBox mbox
 			(&eia(), _("Error Saving Map!"), s, UI::WLMessageBox::YESNO);
 		if (!mbox.run())
 			return false;
 
-		g_fs->Unlink(complete_filename);
+		g_fs->fs_unlink(complete_filename);
 	}
 
 	std::unique_ptr<FileSystem> fs
-			(g_fs->CreateSubFileSystem(complete_filename, binary ? FileSystem::ZIP : FileSystem::DIR));
+			(g_fs->create_sub_file_system(complete_filename, binary ? FileSystem::ZIP : FileSystem::DIR));
 	Widelands::MapSaver wms(*fs, eia().egbase());
 	try {
 		wms.save();

=== modified file 'src/editor/ui_menus/editor_main_menu_save_map_make_directory.cc'
--- src/editor/ui_menus/editor_main_menu_save_map_make_directory.cc	2014-09-10 14:08:25 +0000
+++ src/editor/ui_menus/editor_main_menu_save_map_make_directory.cc	2014-09-29 14:39:47 +0000
@@ -42,7 +42,7 @@
 		new UI::EditBox
 			(this, spacing, posy, get_inner_w() - 2 * spacing, 20,
 			 g_gr->images().get("pics/but1.png"));
-	m_edit->setText(dirname);
+	m_edit->set_text(dirname);
 	m_dirname = dirname;
 	m_edit->changed.connect(boost::bind(&MainMenuSaveMapMakeDirectory::edit_changed, this));
 

=== modified file 'src/editor/ui_menus/editor_player_menu.cc'
--- src/editor/ui_menus/editor_player_menu.cc	2014-09-10 14:08:25 +0000
+++ src/editor/ui_menus/editor_player_menu.cc	2014-09-29 14:39:47 +0000
@@ -147,7 +147,7 @@
 			m_plr_names[p - 1]->changed.connect
 				(boost::bind(&EditorPlayerMenu::name_changed, this, p - 1));
 			posx += 140 + spacing;
-			m_plr_names[p - 1]->setText(map.get_scenario_player_name(p));
+			m_plr_names[p - 1]->set_text(map.get_scenario_player_name(p));
 		}
 
 		if (!m_plr_set_tribes_buts[p - 1]) {
@@ -356,7 +356,7 @@
 	//  Register callback function to make sure that only valid locations are
 	//  selected.
 	map.overlay_manager().register_overlay_callback_function(
-	   boost::bind(&Editor_Tool_Set_Starting_Pos_Callback, _1, boost::ref(map)));
+	   boost::bind(&editor_tool_set_starting_pos_callback, _1, boost::ref(map)));
 	map.recalc_whole_map(menu.egbase().world());
 	update();
 }
@@ -372,10 +372,10 @@
 	Widelands::Map & map = menu.egbase().map();
 	if (text == "") {
 		text = map.get_scenario_player_name(m + 1);
-		m_plr_names[m]->setText(text);
+		m_plr_names[m]->set_text(text);
 	}
 	map.set_scenario_player_name(m + 1, text);
-	m_plr_names[m]->setText(map.get_scenario_player_name(m + 1));
+	m_plr_names[m]->set_text(map.get_scenario_player_name(m + 1));
 	menu.set_need_save(true);
 }
 
@@ -441,6 +441,6 @@
 	parent.select_tool(parent.tools.make_infrastructure, EditorTool::First);
 	parent.tools.make_infrastructure.set_player(n);
 	overlay_manager.register_overlay_callback_function(
-	   boost::bind(&Editor_Make_Infrastructure_Tool_Callback, _1, boost::ref(egbase), n));
+	   boost::bind(&editor_make_infrastructure_tool_callback, _1, boost::ref(egbase), n));
 	map.recalc_whole_map(egbase.world());
 }

=== modified file 'src/editor/ui_menus/editor_tool_change_resources_options_menu.cc'
--- src/editor/ui_menus/editor_tool_change_resources_options_menu.cc	2014-09-10 14:08:25 +0000
+++ src/editor/ui_menus/editor_tool_change_resources_options_menu.cc	2014-09-29 14:39:47 +0000
@@ -215,7 +215,7 @@
 	Widelands::EditorGameBase& egbase = ref_cast<EditorInteractive, UI::Panel>(*get_parent()).egbase();
 	Widelands::Map & map = egbase.map();
 	map.overlay_manager().register_overlay_callback_function(
-	   boost::bind(&Editor_Change_Resource_Tool_Callback, _1, boost::ref(map), boost::ref(egbase.world()), n));
+	   boost::bind(&editor_change_resource_tool_callback, _1, boost::ref(map), boost::ref(egbase.world()), n));
 	map.recalc_whole_map(egbase.world());
 	select_correct_tool();
 

=== modified file 'src/editor/ui_menus/editor_tool_menu.cc'
--- src/editor/ui_menus/editor_tool_menu.cc	2014-09-10 14:08:25 +0000
+++ src/editor/ui_menus/editor_tool_menu.cc	2014-09-29 14:39:47 +0000
@@ -142,7 +142,7 @@
 		// Set correct overlay
 		Widelands::Map & map = parent.egbase().map();
 		map.overlay_manager().register_overlay_callback_function(
-				boost::bind(&Editor_Tool_Set_Port_Space_Callback, _1, boost::ref(map)));
+				boost::bind(&editor_Tool_set_port_space_callback, _1, boost::ref(map)));
 		map.recalc_whole_map(parent.egbase().world());
 		update();
 	}

=== modified file 'src/game_io/game_class_packet.cc'
--- src/game_io/game_class_packet.cc	2014-09-10 08:55:04 +0000
+++ src/game_io/game_class_packet.cc	2014-09-29 14:39:47 +0000
@@ -29,16 +29,16 @@
 #define CURRENT_PACKET_VERSION 2
 
 
-void GameClassPacket::Read
+void GameClassPacket::read
 	(FileSystem & fs, Game & game, MapObjectLoader *)
 {
 	try {
 		FileRead fr;
-		fr.Open(fs, "binary/game_class");
-		uint16_t const packet_version = fr.Unsigned16();
+		fr.open(fs, "binary/game_class");
+		uint16_t const packet_version = fr.unsigned_16();
 		if (packet_version <= CURRENT_PACKET_VERSION) {
-			fr.Signed16(); // This used to be game speed
-			game.gametime_ = fr.Unsigned32();
+			fr.signed_16(); // This used to be game speed
+			game.gametime_ = fr.unsigned_32();
 		} else
 			throw GameDataError
 				("unknown/unhandled version %u", packet_version);
@@ -50,17 +50,17 @@
 /*
  * Write Function
  */
-void GameClassPacket::Write
+void GameClassPacket::write
 	(FileSystem & fs, Game & game, MapObjectSaver * const)
 {
 	FileWrite fw;
 
 	// Packet version
-	fw.Unsigned16(CURRENT_PACKET_VERSION);
+	fw.unsigned_16(CURRENT_PACKET_VERSION);
 
 	// State is running, we do not need to save this
 	// Save speed
-	fw.Signed16(1000);
+	fw.signed_16(1000);
 
 	// From the interactive player, is saved somewhere else
 	// Computer players are saved somewhere else
@@ -70,7 +70,7 @@
 
 	// EDITOR GAME CLASS
 	// Write gametime
-	fw.Unsigned32(game.gametime_);
+	fw.unsigned_32(game.gametime_);
 
 	// We do not care for players, since they were set
 	// on game initialization to match Map::scenario_player_[names|tribes]
@@ -85,7 +85,7 @@
 
 	// Track pointers are not saved in save games
 
-	fw.Write(fs, "binary/game_class");
+	fw.write(fs, "binary/game_class");
 }
 
 }

=== modified file 'src/game_io/game_class_packet.h'
--- src/game_io/game_class_packet.h	2014-09-10 16:57:31 +0000
+++ src/game_io/game_class_packet.h	2014-09-29 14:39:47 +0000
@@ -29,8 +29,8 @@
  * a game for a user (for example in a listbox)
  */
 struct GameClassPacket : public GameDataPacket {
-	void Read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
-	void Write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
+	void read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
+	void write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
 };
 
 }

=== modified file 'src/game_io/game_cmd_queue_packet.cc'
--- src/game_io/game_cmd_queue_packet.cc	2014-09-14 16:08:13 +0000
+++ src/game_io/game_cmd_queue_packet.cc	2014-09-29 14:39:47 +0000
@@ -32,47 +32,47 @@
 #define CURRENT_PACKET_VERSION 2
 
 
-void GameCmdQueuePacket::Read
+void GameCmdQueuePacket::read
 	(FileSystem & fs, Game & game, MapObjectLoader * const ol)
 {
 	try {
 		FileRead fr;
-		fr.Open(fs, "binary/cmd_queue");
-		uint16_t const packet_version = fr.Unsigned16();
+		fr.open(fs, "binary/cmd_queue");
+		uint16_t const packet_version = fr.unsigned_16();
 		if (packet_version == CURRENT_PACKET_VERSION) {
 			CmdQueue & cmdq = game.cmdqueue();
 
 			// nothing to be done for m_game
 
 			// Next serial
-			cmdq.nextserial = fr.Unsigned32();
+			cmdq.nextserial = fr.unsigned_32();
 
 			// Erase all currently pending commands in the queue
 			cmdq.flush();
 
 			for (;;) {
-				uint32_t const packet_id = fr.Unsigned16();
+				uint32_t const packet_id = fr.unsigned_16();
 
 				if (!packet_id)
 					break;
 
 				CmdQueue::CmdItem item;
-				item.category = fr.Signed32();
-				item.serial = fr.Unsigned32();
+				item.category = fr.signed_32();
+				item.serial = fr.unsigned_32();
 
 				if (packet_id == 129) {
 					// For backwards compatibility with savegames up to build15:
 					// Discard old CheckEventChain commands
-					fr.Unsigned16(); // CheckEventChain version
-					fr.Unsigned16(); // GameLogicCommand version
-					fr.Unsigned32(); // GameLogicCommand duetime
-					fr.Unsigned16(); // CheckEventChain ID
+					fr.unsigned_16(); // CheckEventChain version
+					fr.unsigned_16(); // GameLogicCommand version
+					fr.unsigned_32(); // GameLogicCommand duetime
+					fr.unsigned_16(); // CheckEventChain ID
 					continue;
 				}
 
 				GameLogicCommand & cmd =
 					QueueCmdFactory::create_correct_queue_command(packet_id);
-				cmd.Read(fr, game, *ol);
+				cmd.read(fr, game, *ol);
 
 				item.cmd = &cmd;
 
@@ -88,20 +88,20 @@
 }
 
 
-void GameCmdQueuePacket::Write
+void GameCmdQueuePacket::write
 	(FileSystem & fs, Game & game, MapObjectSaver * const os)
 {
 	FileWrite fw;
 
 	// Now packet version
-	fw.Unsigned16(CURRENT_PACKET_VERSION);
+	fw.unsigned_16(CURRENT_PACKET_VERSION);
 
 	const CmdQueue & cmdq = game.cmdqueue();
 
 	// nothing to be done for m_game
 
 	// Next serial
-	fw.Unsigned32(cmdq.nextserial);
+	fw.unsigned_32(cmdq.nextserial);
 
 	// Write all commands
 
@@ -118,14 +118,14 @@
 			if (it.cmd->duetime() == time) {
 				if (upcast(GameLogicCommand, cmd, it.cmd)) {
 					// The id (aka command type)
-					fw.Unsigned16(cmd->id());
+					fw.unsigned_16(cmd->id());
 
 					// Serial number
-					fw.Signed32(it.category);
-					fw.Unsigned32(it.serial);
+					fw.signed_32(it.category);
+					fw.unsigned_32(it.serial);
 
 					// Now the command itself
-					cmd->Write(fw, game, *os);
+					cmd->write(fw, game, *os);
 				}
 				++ nhandled;
 			}
@@ -137,9 +137,9 @@
 	}
 
 
-	fw.Unsigned16(0); // end of command queue
+	fw.unsigned_16(0); // end of command queue
 
-	fw.Write(fs, "binary/cmd_queue");
+	fw.write(fs, "binary/cmd_queue");
 }
 
 }

=== modified file 'src/game_io/game_cmd_queue_packet.h'
--- src/game_io/game_cmd_queue_packet.h	2014-09-10 16:57:31 +0000
+++ src/game_io/game_cmd_queue_packet.h	2014-09-29 14:39:47 +0000
@@ -31,8 +31,8 @@
  * a game for a user (for example in a listbox)
  */
 struct GameCmdQueuePacket : public GameDataPacket {
-	void Read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
-	void Write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
+	void read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
+	void write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
 };
 
 }

=== modified file 'src/game_io/game_data_packet.h'
--- src/game_io/game_data_packet.h	2014-09-10 07:57:29 +0000
+++ src/game_io/game_data_packet.h	2014-09-29 14:39:47 +0000
@@ -40,8 +40,8 @@
 */
 struct GameDataPacket {
 	virtual ~GameDataPacket() {}
-	virtual void Read (FileSystem &, Game &, MapObjectLoader * = nullptr) = 0;
-	virtual void Write(FileSystem &, Game &, MapObjectSaver  * = nullptr) = 0;
+	virtual void read (FileSystem &, Game &, MapObjectLoader * = nullptr) = 0;
+	virtual void write(FileSystem &, Game &, MapObjectSaver  * = nullptr) = 0;
 };
 
 }

=== modified file 'src/game_io/game_interactive_player_packet.cc'
--- src/game_io/game_interactive_player_packet.cc	2014-09-10 13:03:40 +0000
+++ src/game_io/game_interactive_player_packet.cc	2014-09-29 14:39:47 +0000
@@ -34,15 +34,15 @@
 #define CURRENT_PACKET_VERSION 2
 
 
-void GameInteractivePlayerPacket::Read
+void GameInteractivePlayerPacket::read
 	(FileSystem & fs, Game & game, MapObjectLoader *)
 {
 	try {
 		FileRead fr;
-		fr.Open(fs, "binary/interactive_player");
-		uint16_t const packet_version = fr.Unsigned16();
+		fr.open(fs, "binary/interactive_player");
+		uint16_t const packet_version = fr.unsigned_16();
 		if (packet_version == CURRENT_PACKET_VERSION) {
-			PlayerNumber player_number = fr.Unsigned8();
+			PlayerNumber player_number = fr.unsigned_8();
 			if (!(0 < player_number && player_number <= game.map().get_nrplayers())) {
 				throw GameDataError("Invalid player number: %i.", player_number);
 			}
@@ -59,9 +59,9 @@
 				if (player_number > max)
 					throw GameDataError("The game has no players!");
 			}
-			int32_t       const x             = fr.Unsigned16();
-			int32_t       const y             = fr.Unsigned16();
-			uint32_t      const display_flags = fr.Unsigned32();
+			int32_t       const x             = fr.unsigned_16();
+			int32_t       const y             = fr.unsigned_16();
+			uint32_t      const display_flags = fr.unsigned_32();
 
 			if (InteractiveBase * const ibase = game.get_ibase()) {
 				ibase->set_viewpoint(Point(x, y), true);
@@ -88,32 +88,32 @@
 /*
  * Write Function
  */
-void GameInteractivePlayerPacket::Write
+void GameInteractivePlayerPacket::write
 	(FileSystem & fs, Game & game, MapObjectSaver * const)
 {
 	FileWrite fw;
 
 	// Now packet version
-	fw.Unsigned16(CURRENT_PACKET_VERSION);
+	fw.unsigned_16(CURRENT_PACKET_VERSION);
 
 	InteractiveBase * const ibase = game.get_ibase();
 	InteractivePlayer * const iplayer = game.get_ipl();
 
 	// Player number
-	fw.Unsigned8(iplayer ? iplayer->player_number() : 1);
+	fw.unsigned_8(iplayer ? iplayer->player_number() : 1);
 
 	// Map Position
 	if (ibase) {
 		assert(0 <= ibase->get_viewpoint().x);
 		assert(0 <= ibase->get_viewpoint().y);
 	}
-	fw.Unsigned16(ibase ? ibase->get_viewpoint().x : 0);
-	fw.Unsigned16(ibase ? ibase->get_viewpoint().y : 0);
+	fw.unsigned_16(ibase ? ibase->get_viewpoint().x : 0);
+	fw.unsigned_16(ibase ? ibase->get_viewpoint().y : 0);
 
 	// Display flags
-	fw.Unsigned32(ibase ? ibase->get_display_flags() : 0);
+	fw.unsigned_32(ibase ? ibase->get_display_flags() : 0);
 
-	fw.Write(fs, "binary/interactive_player");
+	fw.write(fs, "binary/interactive_player");
 }
 
 }

=== modified file 'src/game_io/game_interactive_player_packet.h'
--- src/game_io/game_interactive_player_packet.h	2014-09-10 16:57:31 +0000
+++ src/game_io/game_interactive_player_packet.h	2014-09-29 14:39:47 +0000
@@ -29,8 +29,8 @@
  * player number and so on
  */
 struct GameInteractivePlayerPacket : public GameDataPacket {
-	void Read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
-	void Write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
+	void read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
+	void write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
 };
 
 }

=== modified file 'src/game_io/game_loader.cc'
--- src/game_io/game_loader.cc	2014-09-18 18:56:20 +0000
+++ src/game_io/game_loader.cc	2014-09-29 14:39:47 +0000
@@ -39,7 +39,7 @@
 namespace Widelands {
 
 GameLoader::GameLoader(const std::string & path, Game & game) :
-	m_fs(*g_fs->MakeSubFileSystem(path)), m_game(game)
+	m_fs(*g_fs->make_sub_file_system(path)), m_game(game)
 {}
 
 
@@ -52,7 +52,7 @@
  */
 int32_t GameLoader::preload_game(GamePreloadPacket & mp) {
 	// Load elemental data block
-	mp.Read(m_fs, m_game, nullptr);
+	mp.read(m_fs, m_game, nullptr);
 
 	return 0;
 }
@@ -64,33 +64,33 @@
 	ScopedTimer timer("GameLoader::load() took %ums");
 
 	log("Game: Reading Preload Data ... ");
-	{GamePreloadPacket                     p; p.Read(m_fs, m_game);}
+	{GamePreloadPacket                     p; p.read(m_fs, m_game);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Reading Game Class Data ... ");
-	{GameClassPacket                  p; p.Read(m_fs, m_game);}
+	{GameClassPacket                  p; p.read(m_fs, m_game);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Reading Map Data ... ");
-	GameMapPacket M;                          M.Read(m_fs, m_game);
+	GameMapPacket M;                          M.read(m_fs, m_game);
 	log("Game: Reading Map Data took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Reading Player Info ... ");
-	{GamePlayerInfoPacket                 p; p.Read(m_fs, m_game);}
+	{GamePlayerInfoPacket                 p; p.read(m_fs, m_game);}
 	log("Game: Reading Player Info took %ums\n", timer.ms_since_last_query());
 
-	log("Game: Calling Read_Complete()\n");
-	M.Read_Complete(m_game);
-	log("Game: Read_Complete took: %ums\n", timer.ms_since_last_query());
+	log("Game: Calling read_complete()\n");
+	M.read_complete(m_game);
+	log("Game: read_complete took: %ums\n", timer.ms_since_last_query());
 
 	MapObjectLoader * const mol = M.get_map_object_loader();
 
 	log("Game: Reading Player Economies Info ... ");
-	{GamePlayerEconomiesPacket            p; p.Read(m_fs, m_game, mol);}
+	{GamePlayerEconomiesPacket            p; p.read(m_fs, m_game, mol);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Reading Command Queue Data ... ");
-	{GameCmdQueuePacket                   p; p.Read(m_fs, m_game, mol);}
+	{GameCmdQueuePacket                   p; p.read(m_fs, m_game, mol);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	//  This must be after the command queue has been read.
@@ -120,7 +120,7 @@
 	// player.
 	if (!multiplayer) {
 		log("Game: Reading Interactive Player Data ... ");
-		{GameInteractivePlayerPacket       p; p.Read(m_fs, m_game, mol);}
+		{GameInteractivePlayerPacket       p; p.read(m_fs, m_game, mol);}
 		log("took %ums\n", timer.ms_since_last_query());
 	}
 

=== modified file 'src/game_io/game_map_packet.cc'
--- src/game_io/game_map_packet.cc	2014-09-10 07:57:29 +0000
+++ src/game_io/game_map_packet.cc	2014-09-29 14:39:47 +0000
@@ -34,16 +34,16 @@
 	delete m_wml;
 }
 
-void GameMapPacket::Read
+void GameMapPacket::read
 	(FileSystem & fs, Game & game, MapObjectLoader * const)
 {
-	if (!fs.FileExists("map") || !fs.IsDirectory("map"))
+	if (!fs.file_exists("map") || !fs.is_directory("map"))
 		throw GameDataError("no map");
 
 	//  Now Load the map as it would be a normal map saving.
 	delete m_wml;
 
-	m_wml = new WidelandsMapLoader(fs.MakeSubFileSystem("map"), &game.map());
+	m_wml = new WidelandsMapLoader(fs.make_sub_file_system("map"), &game.map());
 
 	m_wml->preload_map(true);
 
@@ -53,18 +53,18 @@
 }
 
 
-void GameMapPacket::Read_Complete(Game & game) {
+void GameMapPacket::read_complete(Game & game) {
 	m_wml->load_map_complete(game, true);
 	m_mol = m_wml->get_map_object_loader();
 }
 
 
-void GameMapPacket::Write
+void GameMapPacket::write
 	(FileSystem & fs, Game & game, MapObjectSaver * const)
 {
 
 	std::unique_ptr<FileSystem> mapfs
-		(fs.CreateSubFileSystem("map", FileSystem::DIR));
+		(fs.create_sub_file_system("map", FileSystem::DIR));
 
 	//  Now Write the map as it would be a normal map saving.
 	delete m_wms;

=== modified file 'src/game_io/game_map_packet.h'
--- src/game_io/game_map_packet.h	2014-09-10 16:57:31 +0000
+++ src/game_io/game_map_packet.h	2014-09-29 14:39:47 +0000
@@ -36,11 +36,11 @@
 
 
 	/// Ensures that the world gets loaded but does not much more.
-	void Read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
-
-	void Read_Complete(Game &); ///  Loads the rest of the map.
-
-	void Write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
+	void read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
+
+	void read_complete(Game &); ///  Loads the rest of the map.
+
+	void write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
 
 	MapObjectSaver  * get_map_object_saver () {return m_mos;}
 	MapObjectLoader * get_map_object_loader() {return m_mol;}

=== modified file 'src/game_io/game_player_economies_packet.cc'
--- src/game_io/game_player_economies_packet.cc	2014-09-10 08:55:04 +0000
+++ src/game_io/game_player_economies_packet.cc	2014-09-29 14:39:47 +0000
@@ -35,7 +35,7 @@
 #define CURRENT_PACKET_VERSION 3
 
 
-void GamePlayerEconomiesPacket::Read
+void GamePlayerEconomiesPacket::read
 	(FileSystem & fs, Game & game, MapObjectLoader *)
 {
 	try {
@@ -44,30 +44,30 @@
 		PlayerNumber const nr_players = map.get_nrplayers();
 
 		FileRead fr;
-		fr.Open(fs, "binary/player_economies");
-		uint16_t const packet_version = fr.Unsigned16();
+		fr.open(fs, "binary/player_economies");
+		uint16_t const packet_version = fr.unsigned_16();
 		if (3 <= packet_version && packet_version <= CURRENT_PACKET_VERSION) {
 			iterate_players_existing(p, nr_players, game, player)
 				try {
 					Player::Economies & economies = player->m_economies;
 					for (uint32_t i = 0; i < economies.size(); ++i) {
-						uint32_t value = fr.Unsigned32();
+						uint32_t value = fr.unsigned_32();
 						if (value < 0xffffffff) {
 							if (upcast(Flag const, flag, map[value].get_immovable())) {
 								EconomyDataPacket d(flag->get_economy());
-								d.Read(fr);
+								d.read(fr);
 							} else {
 								throw GameDataError("there is no flag at the specified location");
 							}
 						} else {
 							bool read_this_economy = false;
 
-							Bob* bob = map[ReadMap_Index32(&fr, max_index)].get_first_bob();
+							Bob* bob = map[read_map_index_32(&fr, max_index)].get_first_bob();
 							while (bob) {
 								if (upcast(Ship const, ship, bob)) {
 									assert(ship->get_economy());
 									EconomyDataPacket d(ship->get_economy());
-									d.Read(fr);
+									d.read(fr);
 									read_this_economy = true;
 								}
 								bob = bob->get_next_bob();
@@ -91,12 +91,12 @@
 /*
  * Write Function
  */
-void GamePlayerEconomiesPacket::Write
+void GamePlayerEconomiesPacket::write
 	(FileSystem & fs, Game & game, MapObjectSaver * const)
 {
 	FileWrite fw;
 
-	fw.Unsigned16(CURRENT_PACKET_VERSION);
+	fw.unsigned_16(CURRENT_PACKET_VERSION);
 
 	const Map & map = game.map();
 	const Field & field_0 = map[0];
@@ -110,10 +110,10 @@
 			for (Field const * field = &field_0; field < &map[map.max_index()]; ++field) {
 				if (upcast(Flag const, flag, field->get_immovable())) {
 					if (flag->get_economy() == temp_economy) {
-						fw.Unsigned32(field - &field_0);
+						fw.unsigned_32(field - &field_0);
 
 						EconomyDataPacket d(flag->get_economy());
-						d.Write(fw);
+						d.write(fw);
 						wrote_this_economy = true;
 						break;
 					}
@@ -131,11 +131,11 @@
 						if (upcast(Ship const, ship, bob)) {
 							if (ship->get_economy() == temp_economy) {
 								// TODO(sirver): the 0xffffffff is ugly and fragile.
-								fw.Unsigned32(0xffffffff); // Sentinel value.
-								fw.Unsigned32(field - &field_0);
+								fw.unsigned_32(0xffffffff); // Sentinel value.
+								fw.unsigned_32(field - &field_0);
 
 								EconomyDataPacket d(ship->get_economy());
-								d.Write(fw);
+								d.write(fw);
 								wrote_this_economy = true;
 							}
 						}
@@ -149,7 +149,7 @@
 		}
 	}
 
-	fw.Write(fs, "binary/player_economies");
+	fw.write(fs, "binary/player_economies");
 }
 
 }

=== modified file 'src/game_io/game_player_economies_packet.h'
--- src/game_io/game_player_economies_packet.h	2014-09-10 16:57:31 +0000
+++ src/game_io/game_player_economies_packet.h	2014-09-29 14:39:47 +0000
@@ -28,8 +28,8 @@
  * how many and which economies does a player have?
  */
 struct GamePlayerEconomiesPacket : public GameDataPacket {
-	void Read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
-	void Write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
+	void read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
+	void write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
 };
 
 }

=== modified file 'src/game_io/game_player_info_packet.cc'
--- src/game_io/game_player_info_packet.cc	2014-09-10 08:55:04 +0000
+++ src/game_io/game_player_info_packet.cc	2014-09-29 14:39:47 +0000
@@ -33,61 +33,61 @@
 #define CURRENT_PACKET_VERSION 15
 
 
-void GamePlayerInfoPacket::Read
+void GamePlayerInfoPacket::read
 	(FileSystem & fs, Game & game, MapObjectLoader *)
 {
 	try {
 		FileRead fr;
-		fr.Open(fs, "binary/player_info");
-		uint16_t const packet_version = fr.Unsigned16();
+		fr.open(fs, "binary/player_info");
+		uint16_t const packet_version = fr.unsigned_16();
 		if (5 <= packet_version && packet_version <= CURRENT_PACKET_VERSION) {
-			uint32_t const max_players = fr.Unsigned16();
+			uint32_t const max_players = fr.unsigned_16();
 			for (uint32_t i = 1; i < max_players + 1; ++i) {
 				game.remove_player(i);
-				if (fr.Unsigned8()) {
-					bool const see_all = fr.Unsigned8();
+				if (fr.unsigned_8()) {
+					bool const see_all = fr.unsigned_8();
 
-					int32_t const plnum = fr.Unsigned8();
+					int32_t const plnum = fr.unsigned_8();
 					if (plnum < 1 || MAX_PLAYERS < plnum)
 						throw GameDataError
 							("player number (%i) is out of range (1 .. %u)",
 							 plnum, MAX_PLAYERS);
 					Widelands::TeamNumber team = 0;
 					if (packet_version >= 9)
-						team = fr.Unsigned8();
-
-					char const * const tribe_name = fr.CString();
-
-					std::string const name = fr.CString();
+						team = fr.unsigned_8();
+
+					char const * const tribe_name = fr.c_string();
+
+					std::string const name = fr.c_string();
 
 					game.add_player(plnum, 0, tribe_name, name, team);
 					Player & player = game.player(plnum);
 					player.set_see_all(see_all);
 
-					player.setAI(fr.CString());
+					player.set_ai(fr.c_string());
 
 					if (packet_version >= 15)
-						player.ReadStatistics(fr, 3);
+						player.read_statistics(fr, 3);
 					else if (packet_version >= 14)
-						player.ReadStatistics(fr, 2);
+						player.read_statistics(fr, 2);
 					else if (packet_version >= 12)
-						player.ReadStatistics(fr, 1);
+						player.read_statistics(fr, 1);
 					else
-						player.ReadStatistics(fr, 0);
+						player.read_statistics(fr, 0);
 
-					player.m_casualties = fr.Unsigned32();
-					player.m_kills      = fr.Unsigned32();
-					player.m_msites_lost         = fr.Unsigned32();
-					player.m_msites_defeated     = fr.Unsigned32();
-					player.m_civil_blds_lost     = fr.Unsigned32();
-					player.m_civil_blds_defeated = fr.Unsigned32();
+					player.m_casualties = fr.unsigned_32();
+					player.m_kills      = fr.unsigned_32();
+					player.m_msites_lost         = fr.unsigned_32();
+					player.m_msites_defeated     = fr.unsigned_32();
+					player.m_civil_blds_lost     = fr.unsigned_32();
+					player.m_civil_blds_defeated = fr.unsigned_32();
 				}
 			}
 
 			if (packet_version <= 10)
-				game.ReadStatistics(fr, 3);
+				game.read_statistics(fr, 3);
 			else
-				game.ReadStatistics(fr, 4);
+				game.read_statistics(fr, 4);
 		} else
 			throw GameDataError
 				("unknown/unhandled version %u", packet_version);
@@ -97,48 +97,48 @@
 }
 
 
-void GamePlayerInfoPacket::Write
+void GamePlayerInfoPacket::write
 	(FileSystem & fs, Game & game, MapObjectSaver *)
 {
 	FileWrite fw;
 
 	// Now packet version
-	fw.Unsigned16(CURRENT_PACKET_VERSION);
+	fw.unsigned_16(CURRENT_PACKET_VERSION);
 
 	// Number of (potential) players
 	PlayerNumber const nr_players = game.map().get_nrplayers();
-	fw.Unsigned16(nr_players);
+	fw.unsigned_16(nr_players);
 	iterate_players_existing_const(p, nr_players, game, plr) {
-		fw.Unsigned8(1); // Player is in game.
-
-		fw.Unsigned8(plr->m_see_all);
-
-		fw.Unsigned8(plr->m_plnum);
-		fw.Unsigned8(plr->team_number());
-
-		fw.CString(plr->tribe().name().c_str());
+		fw.unsigned_8(1); // Player is in game.
+
+		fw.unsigned_8(plr->m_see_all);
+
+		fw.unsigned_8(plr->m_plnum);
+		fw.unsigned_8(plr->team_number());
+
+		fw.c_string(plr->tribe().name().c_str());
 
 		// Seen fields is in a map packet
 		// Allowed buildings is in a map packet
 
 		// Economies are in a packet after map loading
 
-		fw.CString(plr->m_name.c_str());
-		fw.CString(plr->m_ai.c_str());
+		fw.c_string(plr->m_name.c_str());
+		fw.c_string(plr->m_ai.c_str());
 
-		plr->WriteStatistics(fw);
-		fw.Unsigned32(plr->casualties());
-		fw.Unsigned32(plr->kills     ());
-		fw.Unsigned32(plr->msites_lost        ());
-		fw.Unsigned32(plr->msites_defeated    ());
-		fw.Unsigned32(plr->civil_blds_lost    ());
-		fw.Unsigned32(plr->civil_blds_defeated());
+		plr->write_statistics(fw);
+		fw.unsigned_32(plr->casualties());
+		fw.unsigned_32(plr->kills     ());
+		fw.unsigned_32(plr->msites_lost        ());
+		fw.unsigned_32(plr->msites_defeated    ());
+		fw.unsigned_32(plr->civil_blds_lost    ());
+		fw.unsigned_32(plr->civil_blds_defeated());
 	} else
-		fw.Unsigned8(0); //  Player is NOT in game.
-
-	game.WriteStatistics(fw);
-
-	fw.Write(fs, "binary/player_info");
+		fw.unsigned_8(0); //  Player is NOT in game.
+
+	game.write_statistics(fw);
+
+	fw.write(fs, "binary/player_info");
 }
 
 }

=== modified file 'src/game_io/game_player_info_packet.h'
--- src/game_io/game_player_info_packet.h	2014-09-10 16:57:31 +0000
+++ src/game_io/game_player_info_packet.h	2014-09-29 14:39:47 +0000
@@ -29,8 +29,8 @@
  * a game for a user (for example in a listbox)
  */
 struct GamePlayerInfoPacket : public GameDataPacket {
-	void Read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
-	void Write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
+	void read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
+	void write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
 };
 
 }

=== modified file 'src/game_io/game_preload_packet.cc'
--- src/game_io/game_preload_packet.cc	2014-09-10 13:03:40 +0000
+++ src/game_io/game_preload_packet.cc	2014-09-29 14:39:47 +0000
@@ -45,7 +45,7 @@
 #define MINIMAP_FILENAME "minimap.png"
 
 
-void GamePreloadPacket::Read
+void GamePreloadPacket::read
 	(FileSystem & fs, Game &, MapObjectLoader * const)
 {
 	try {
@@ -62,7 +62,7 @@
 			m_player_nr = s.get_safe_int("player_nr");
 			m_win_condition = s.get_safe_string("win_condition");
 			m_number_of_players = s.get_safe_int(PLAYERS_AMOUNT_KEY_V4);
-			if (fs.FileExists(MINIMAP_FILENAME)) {
+			if (fs.file_exists(MINIMAP_FILENAME)) {
 				m_minimap_path = MINIMAP_FILENAME;
 			}
 		} else {
@@ -75,7 +75,7 @@
 }
 
 
-void GamePreloadPacket::Write
+void GamePreloadPacket::write
 	(FileSystem & fs, Game & game, MapObjectSaver * const)
 {
 
@@ -116,10 +116,10 @@
 	if (ipl != nullptr) {
 		const MiniMapLayer flags = MiniMapLayer::Owner | MiniMapLayer::Building | MiniMapLayer::Terrain;
 		const Point& vp = ipl->get_viewpoint();
-		std::unique_ptr< ::StreamWrite> sw(fs.OpenStreamWrite(MINIMAP_FILENAME));
+		std::unique_ptr< ::StreamWrite> sw(fs.open_stream_write(MINIMAP_FILENAME));
 		if (sw.get() != nullptr) {
 			write_minimap_image(game, &ipl->player(), vp, flags, sw.get());
-			sw->Flush();
+			sw->flush();
 		}
 	}
 }

=== modified file 'src/game_io/game_preload_packet.h'
--- src/game_io/game_preload_packet.h	2014-09-10 16:57:31 +0000
+++ src/game_io/game_preload_packet.h	2014-09-29 14:39:47 +0000
@@ -32,8 +32,8 @@
  * a game for a user (for example in a listbox)
  */
 struct GamePreloadPacket : public GameDataPacket {
-	void Read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
-	void Write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
+	void read (FileSystem &, Game &, MapObjectLoader * = nullptr) override;
+	void write(FileSystem &, Game &, MapObjectSaver  * = nullptr) override;
 
 	char const * get_mapname()      {return m_mapname.c_str();}
 	std::string get_background()    {return m_background;}

=== modified file 'src/game_io/game_saver.cc'
--- src/game_io/game_saver.cc	2014-09-10 16:57:31 +0000
+++ src/game_io/game_saver.cc	2014-09-29 14:39:47 +0000
@@ -43,36 +43,36 @@
 void GameSaver::save() {
 	ScopedTimer timer("GameSaver::save() took %ums");
 
-	m_fs.EnsureDirectoryExists("binary");
+	m_fs.ensure_directory_exists("binary");
 
 	log("Game: Writing Preload Data ... ");
-	{GamePreloadPacket                    p; p.Write(m_fs, m_game, nullptr);}
+	{GamePreloadPacket                    p; p.write(m_fs, m_game, nullptr);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Writing Game Class Data ... ");
-	{GameClassPacket                 p; p.Write(m_fs, m_game, nullptr);}
+	{GameClassPacket                 p; p.write(m_fs, m_game, nullptr);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Writing Player Info ... ");
-	{GamePlayerInfoPacket                p; p.Write(m_fs, m_game, nullptr);}
+	{GamePlayerInfoPacket                p; p.write(m_fs, m_game, nullptr);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Writing Map Data!\n");
-	GameMapPacket                         M; M.Write(m_fs, m_game, nullptr);
+	GameMapPacket                         M; M.write(m_fs, m_game, nullptr);
 	log("Game: Writing Map Data took %ums\n", timer.ms_since_last_query());
 
 	MapObjectSaver * const mos = M.get_map_object_saver();
 
 	log("Game: Writing Player Economies Info ... ");
-	{GamePlayerEconomiesPacket           p; p.Write(m_fs, m_game, mos);}
+	{GamePlayerEconomiesPacket           p; p.write(m_fs, m_game, mos);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Writing Command Queue Data ... ");
-	{GameCmdQueuePacket                  p; p.Write(m_fs, m_game, mos);}
+	{GameCmdQueuePacket                  p; p.write(m_fs, m_game, mos);}
 	log("took %ums\n", timer.ms_since_last_query());
 
 	log("Game: Writing Interactive Player Data ... ");
-	{GameInteractivePlayerPacket         p; p.Write(m_fs, m_game, mos);}
+	{GameInteractivePlayerPacket         p; p.write(m_fs, m_game, mos);}
 	log("took %ums\n", timer.ms_since_last_query());
 }
 

=== modified file 'src/graphic/animation.cc'
--- src/graphic/animation.cc	2014-09-14 11:31:58 +0000
+++ src/graphic/animation.cc	2014-09-29 14:39:47 +0000
@@ -173,7 +173,7 @@
 	if (fps > 0)
 		frametime_ = 1000 / fps;
 
-	hotspot_ = section.get_Point("hotspot");
+	hotspot_ = section.get_point("hotspot");
 
 	//  In the filename template, the last sequence of '?' characters (if any)
 	//  is replaced with a number, for example the template "idle_??" is
@@ -193,12 +193,12 @@
 	string filename_wo_ext;
 	while (glob.next(&filename_wo_ext)) {
 		const string filename = filename_wo_ext + ".png";
-		if (!g_fs->FileExists(filename))
+		if (!g_fs->file_exists(filename))
 			break;
 		image_files_.push_back(filename);
 
 		const string pc_filename = filename_wo_ext + "_pc.png";
-		if (g_fs->FileExists(pc_filename)) {
+		if (g_fs->file_exists(pc_filename)) {
 			hasplrclrs_ = true;
 			pc_mask_image_files_.push_back(pc_filename);
 		}

=== modified file 'src/graphic/diranimations.h'
--- src/graphic/diranimations.h	2014-07-28 14:08:41 +0000
+++ src/graphic/diranimations.h	2014-09-29 14:39:47 +0000
@@ -52,7 +52,7 @@
 		m_animations[dir - 1] = anim;
 	}
 
-	static DirAnimations Null() {
+	static DirAnimations null() {
 		return DirAnimations(0); // Since real animation IDs are positive, this is safe
 	}
 

=== modified file 'src/graphic/font.cc'
--- src/graphic/font.cc	2014-09-14 11:31:58 +0000
+++ src/graphic/font.cc	2014-09-29 14:39:47 +0000
@@ -58,9 +58,9 @@
 
 	//  We must keep this File Read open, otherwise the following calls are
 	//  crashing. do not know why...
-	m_fontfile.Open(*g_fs, filename);
+	m_fontfile.open(*g_fs, filename);
 
-	SDL_RWops * const ops = SDL_RWFromMem(m_fontfile.Data(0), m_fontfile.GetSize());
+	SDL_RWops * const ops = SDL_RWFromMem(m_fontfile.data(0), m_fontfile.get_size());
 	if (!ops)
 		throw wexception("could not load font!: RWops Pointer invalid");
 

=== modified file 'src/graphic/graphic.cc'
--- src/graphic/graphic.cc	2014-07-25 13:45:18 +0000
+++ src/graphic/graphic.cc	2014-09-29 14:39:47 +0000
@@ -309,7 +309,7 @@
 		SDL_GL_SwapBuffers();
 		glEnable(GL_TEXTURE_2D);
 
-		GLSurfaceTexture::Initialize(use_arb);
+		GLSurfaceTexture::initialize(use_arb);
 	}
 
 	if (g_opengl)
@@ -341,7 +341,7 @@
 		UI::g_fh->flush();
 
 	if (g_opengl)
-		GLSurfaceTexture::Cleanup();
+		GLSurfaceTexture::cleanup();
 }
 
 Graphic::~Graphic()
@@ -487,7 +487,7 @@
 void Graphic::screenshot(const string& fname) const
 {
 	log("Save screenshot to %s\n", fname.c_str());
-	StreamWrite * sw = g_fs->OpenStreamWrite(fname);
+	StreamWrite * sw = g_fs->open_stream_write(fname);
 	save_surface_to_png(screen_.get(), sw);
 	delete sw;
 }

=== modified file 'src/graphic/image_io.cc'
--- src/graphic/image_io.cc	2014-07-14 10:45:44 +0000
+++ src/graphic/image_io.cc	2014-09-29 14:39:47 +0000
@@ -35,14 +35,14 @@
 
 // A helper function for save_surface_to_png. Writes the compressed data to
 // the StreamWrite.
-void png_write_function(png_structp png_ptr, png_bytep data, png_size_t length) {
-	static_cast<StreamWrite*>(png_get_io_ptr(png_ptr))->Data(data, length);
+void png_write_function(png_structp png_ptr, png_bytep png_data, png_size_t length) {
+	static_cast<StreamWrite*>(png_get_io_ptr(png_ptr))->data(png_data, length);
 }
 
 // A helper function for save_surface_to_png.
 // Flush function to avoid crashes with default libpng flush function
 void png_flush_function(png_structp png_ptr) {
-	static_cast<StreamWrite*>(png_get_io_ptr(png_ptr))->Flush();
+	static_cast<StreamWrite*>(png_get_io_ptr(png_ptr))->flush();
 }
 
 }  // namespace
@@ -55,16 +55,16 @@
 	FileRead fr;
 	bool found;
 	if (fs) {
-		found = fr.TryOpen(*fs, fname);
+		found = fr.try_open(*fs, fname);
 	} else {
-		found = fr.TryOpen(*g_fs, fname);
+		found = fr.try_open(*g_fs, fname);
 	}
 
 	if (!found) {
 		throw ImageNotFound(fname);
 	}
 
-	SDL_Surface* sdlsurf = IMG_Load_RW(SDL_RWFromMem(fr.Data(0), fr.GetSize()), 1);
+	SDL_Surface* sdlsurf = IMG_Load_RW(SDL_RWFromMem(fr.data(0), fr.get_size()), 1);
 	if (!sdlsurf) {
 		throw ImageLoadingError(fname.c_str(), IMG_GetError());
 	}

=== modified file 'src/graphic/render/gamerenderer_gl.cc'
--- src/graphic/render/gamerenderer_gl.cc	2014-09-14 16:08:13 +0000
+++ src/graphic/render/gamerenderer_gl.cc	2014-09-29 14:39:47 +0000
@@ -295,7 +295,7 @@
 		const Texture & texture =
 				*g_gr->get_maptexture_data
 					(world.terrain_descr(ter).get_texture());
-		glBindTexture(GL_TEXTURE_2D, texture.getTexture());
+		glBindTexture(GL_TEXTURE_2D, texture.get_texture());
 		glDrawRangeElements
 			(GL_TRIANGLES,
 			 0, m_patch_size.w * m_patch_size.h - 1,
@@ -472,7 +472,7 @@
 		const Texture & texture =
 				*g_gr->get_maptexture_data
 					(m_egbase->world().terrain_descr(ter).get_texture());
-		glBindTexture(GL_TEXTURE_2D, texture.getTexture());
+		glBindTexture(GL_TEXTURE_2D, texture.get_texture());
 		glDrawArrays
 			(GL_TRIANGLES,
 			 3 * m_terrain_edge_freq_cum[ter], 3 * m_terrain_edge_freq[ter]);

=== modified file 'src/graphic/render/gl_surface_texture.cc'
--- src/graphic/render/gl_surface_texture.cc	2014-07-20 07:44:53 +0000
+++ src/graphic/render/gl_surface_texture.cc	2014-09-29 14:39:47 +0000
@@ -32,7 +32,7 @@
 /**
  * Initial global resources needed for fast offscreen rendering.
  */
-void GLSurfaceTexture::Initialize(bool use_arb) {
+void GLSurfaceTexture::initialize(bool use_arb) {
 	use_arb_ = use_arb;
 
 	// Generate the framebuffer for Offscreen rendering.
@@ -48,7 +48,7 @@
 /**
  * Free global resources.
  */
-void GLSurfaceTexture::Cleanup() {
+void GLSurfaceTexture::cleanup() {
 	if (use_arb_)
 		glDeleteFramebuffers(1, &gl_framebuffer_id_);
 	else

=== modified file 'src/graphic/render/gl_surface_texture.h'
--- src/graphic/render/gl_surface_texture.h	2014-07-26 10:43:23 +0000
+++ src/graphic/render/gl_surface_texture.h	2014-09-29 14:39:47 +0000
@@ -25,10 +25,10 @@
 
 class GLSurfaceTexture : public GLSurface {
 public:
-	// Call this once before using any instance of this class and Cleanup once
+	// Call this once before using any instance of this class and cleanup once
 	// before the program exits.
-	static void Initialize(bool use_arb);
-	static void Cleanup();
+	static void initialize(bool use_arb);
+	static void cleanup();
 
 	GLSurfaceTexture(SDL_Surface * surface, bool intensity = false);
 	GLSurfaceTexture(int w, int h);

=== modified file 'src/graphic/text/font_io.cc'
--- src/graphic/text/font_io.cc	2014-09-10 16:57:31 +0000
+++ src/graphic/text/font_io.cc	2014-09-29 14:39:47 +0000
@@ -41,8 +41,8 @@
 	std::unique_ptr<std::string> memory;
 	{
 		FileRead* fr = new FileRead();
-		fr->Open(*g_fs, filename);
-		memory.reset(new std::string(fr->Data(0), fr->GetSize()));
+		fr->open(*g_fs, filename);
+		memory.reset(new std::string(fr->data(0), fr->get_size()));
 	}
 
 	SDL_RWops* ops = SDL_RWFromConstMem(memory->data(), memory->size());

=== modified file 'src/graphic/text/test/render.cc'
--- src/graphic/text/test/render.cc	2014-07-14 10:45:44 +0000
+++ src/graphic/text/test/render.cc	2014-09-29 14:39:47 +0000
@@ -32,8 +32,8 @@
 
 StandaloneRenderer::StandaloneRenderer() {
 	g_fs = new LayeredFileSystem();
-	g_fs->AddFileSystem(&FileSystem::Create(WIDELANDS_DATA_DIR));
-	g_fs->AddFileSystem(&FileSystem::Create(RICHTEXT_DATA_DIR));
+	g_fs->add_file_system(&FileSystem::create(WIDELANDS_DATA_DIR));
+	g_fs->add_file_system(&FileSystem::create(RICHTEXT_DATA_DIR));
 
 	surface_cache_.reset(create_surface_cache(500 << 20));  // 500 MB
 	image_cache_.reset(new ImageCache(surface_cache_.get()));

=== modified file 'src/graphic/text/test/render_richtext.cc'
--- src/graphic/text/test/render_richtext.cc	2014-07-20 07:44:53 +0000
+++ src/graphic/text/test/render_richtext.cc	2014-09-29 14:39:47 +0000
@@ -123,8 +123,8 @@
 		std::unique_ptr<SDLSurface> surf(
 		   static_cast<SDLSurface*>(standalone_renderer.renderer()->render(txt, w, allowed_tags)));
 
-		std::unique_ptr<FileSystem> fs(&FileSystem::Create("."));
-		std::unique_ptr<StreamWrite> sw(fs->OpenStreamWrite(outname));
+		std::unique_ptr<FileSystem> fs(&FileSystem::create("."));
+		std::unique_ptr<StreamWrite> sw(fs->open_stream_write(outname));
 		if (!save_surface_to_png(surf.get(), sw.get())) {
 			std::cout << "Could not encode PNG." << std::endl;
 		}

=== modified file 'src/graphic/texture.cc'
--- src/graphic/texture.cc	2014-07-17 13:26:23 +0000
+++ src/graphic/texture.cc	2014-09-29 14:39:47 +0000
@@ -51,7 +51,7 @@
 	}
 
 	for (const std::string& fname : texture_files) {
-		if (!g_fs->FileExists(fname)) {
+		if (!g_fs->file_exists(fname)) {
 			throw wexception("Could not find %s.", fname.c_str());
 		}
 

=== modified file 'src/graphic/texture.h'
--- src/graphic/texture.h	2014-07-12 12:35:05 +0000
+++ src/graphic/texture.h	2014-09-29 14:39:47 +0000
@@ -59,7 +59,7 @@
 	RGBColor get_minimap_color(int8_t shade);
 
 	void animate(uint32_t time);
-	uint32_t getTexture() const
+	uint32_t get_texture() const
 		{return m_glFrames.at(m_frame_num)->get_gl_texture();}
 
 private:

=== modified file 'src/io/dedicated_log.cc'
--- src/io/dedicated_log.cc	2014-06-08 21:47:45 +0000
+++ src/io/dedicated_log.cc	2014-09-29 14:39:47 +0000
@@ -97,18 +97,18 @@
 	temp += c.sender.empty() ? "SYSTEM" : c.sender;
 	temp += "</td><td class=\"recipient\"> ->" + c.recipient + "</td><td class=\"message\">";
 	temp += c.msg + "</td></tr>\n";
-	m_chat.Printf("%s", temp.c_str());
-	m_chat.WriteAppend(*root, m_chat_file_path.c_str());
+	m_chat.print_f("%s", temp.c_str());
+	m_chat.write_append(*root, m_chat_file_path.c_str());
 }
 
 /// Add's a spacer to the chat log
-void DedicatedLog::chatAddSpacer() {
+void DedicatedLog::chat_add_spacer() {
 	if (m_chat_file_path.empty())
 		return;
 
-	m_chat.Printf("<tr><td class=\"space\"></td><td class=\"space\"></td>");
-	m_chat.Printf("<td class=\"space\"></td><td class=\"space\"></td></tr>\n");
-	m_chat.WriteAppend(*root, m_chat_file_path.c_str());
+	m_chat.print_f("<tr><td class=\"space\"></td><td class=\"space\"></td>");
+	m_chat.print_f("<td class=\"space\"></td><td class=\"space\"></td></tr>\n");
+	m_chat.write_append(*root, m_chat_file_path.c_str());
 }
 
 
@@ -206,8 +206,8 @@
 		}
 	}
 	temp += "</table>\n";
-	m_chat.Printf("%s", temp.c_str());
-	m_chat.Write(*root, m_info_file_path.c_str());
+	m_chat.print_f("%s", temp.c_str());
+	m_chat.write(*root, m_info_file_path.c_str());
 }
 
 /// Appends the String \arg msg to the log file
@@ -224,8 +224,8 @@
 	temp += "</td><td class=\"log\">";
 	temp += msg;
 	temp += "</td></tr>\n";
-	m_chat.Printf("%s", temp.c_str());
-	m_chat.WriteAppend(*root, m_log_file_path.c_str());
+	m_chat.print_f("%s", temp.c_str());
+	m_chat.write_append(*root, m_log_file_path.c_str());
 }
 
 
@@ -252,8 +252,8 @@
 	m_chat_file_path = path;
 
 	// Initialize the chat file
-	m_chat.Printf("<tr><th>Time</th><th>Sender</th><th>Recipient</th><th>Message</th></tr>");
-	m_chat.Write(*root, m_chat_file_path.c_str()); // Not WriteAppend, to make sure the file is cleared
+	m_chat.print_f("<tr><th>Time</th><th>Sender</th><th>Recipient</th><th>Message</th></tr>");
+	m_chat.write(*root, m_chat_file_path.c_str()); // Not write_append, to make sure the file is cleared
 	return true;
 }
 
@@ -307,8 +307,8 @@
 	m_log_file_path = path;
 
 	// Initialize the log file
-	m_chat.Printf("<tr><th></th><th>Widelands dedicated server log:</th></tr>\n");
-	m_chat.Write(*root, m_log_file_path.c_str()); // Not WriteAppend, to make sure the file is cleared
+	m_chat.print_f("<tr><th></th><th>Widelands dedicated server log:</th></tr>\n");
+	m_chat.write(*root, m_log_file_path.c_str()); // Not write_append, to make sure the file is cleared
 	return true;
 }
 
@@ -323,14 +323,14 @@
  *          written to does not exist, in all other cases true.
  */
 bool DedicatedLog::check_file_writeable(std::string & path) {
-	bool existing = root->FileExists(path);
-	if (existing && root->IsDirectory(path))
+	bool existing = root->file_exists(path);
+	if (existing && root->is_directory(path))
 		return false;
-	if (root->FileIsWriteable(path)) {
+	if (root->file_is_writeable(path)) {
 		if (existing) {
 			std::string rnpath(path + '~');
-			if (root->FileIsWriteable(rnpath))
-				root->Rename(path, rnpath);
+			if (root->file_is_writeable(rnpath))
+				root->fs_rename(path, rnpath);
 			else
 				log("Note: original file %s could not be backuped\n", path.c_str());
 		}

=== modified file 'src/io/dedicated_log.h'
--- src/io/dedicated_log.h	2014-07-13 18:20:03 +0000
+++ src/io/dedicated_log.h	2014-09-29 14:39:47 +0000
@@ -33,7 +33,7 @@
 	static DedicatedLog * get();
 
 	// chat logging functions
-	void   chatAddSpacer();
+	void   chat_add_spacer();
 	void   chat(ChatMessage & c);
 
 	// info logging functions

=== modified file 'src/io/fileread.cc'
--- src/io/fileread.cc	2014-09-09 17:15:20 +0000
+++ src/io/fileread.cc	2014-09-29 14:39:47 +0000
@@ -23,19 +23,19 @@
 
 FileRead::~FileRead() {
 	if (data_) {
-		Close();
+		close();
 	}
 }
 
-void FileRead::Open(FileSystem& fs, const std::string& filename) {
+void FileRead::open(FileSystem& fs, const std::string& filename) {
 	assert(!data_);
-	data_ = static_cast<char*>(fs.Load(filename, length_));
+	data_ = static_cast<char*>(fs.load(filename, length_));
 	filepos_ = 0;
 }
 
-bool FileRead::TryOpen(FileSystem& fs, const std::string& filename) {
+bool FileRead::try_open(FileSystem& fs, const std::string& filename) {
 	try {
-		Open(fs, filename);
+		open(fs, filename);
 	}
 	catch (const std::exception&) {
 		return false;
@@ -43,32 +43,32 @@
 	return true;
 }
 
-void FileRead::Close() {
+void FileRead::close() {
 	assert(data_);
 	free(data_);
 	data_ = nullptr;
 }
 
-size_t FileRead::GetSize() const {
+size_t FileRead::get_size() const {
 	return length_;
 }
 
-bool FileRead::EndOfFile() const {
+bool FileRead::end_of_file() const {
 	return length_ <= filepos_;
 }
 
-void FileRead::SetFilePos(Pos const pos) {
+void FileRead::set_file_pos(Pos const pos) {
 	assert(data_);
 	if (pos >= length_)
 		throw FileBoundaryExceeded();
 	filepos_ = pos;
 }
 
-FileRead::Pos FileRead::GetPos() const {
+FileRead::Pos FileRead::get_pos() const {
 	return filepos_;
 }
 
-size_t FileRead::Data(void* dst, size_t bufsize) {
+size_t FileRead::data(void* dst, size_t bufsize) {
 	assert(data_);
 	size_t read = 0;
 	for (; read < bufsize && filepos_ < length_; ++read, ++filepos_) {
@@ -77,10 +77,10 @@
 	return read;
 }
 
-char* FileRead::Data(uint32_t const bytes, const Pos pos) {
+char* FileRead::data(uint32_t const bytes, const Pos pos) {
 	assert(data_);
 	Pos i = pos;
-	if (pos.isNull()) {
+	if (pos.is_null()) {
 		i = filepos_;
 		filepos_ += bytes;
 	}
@@ -89,10 +89,10 @@
 	return data_ + i;
 }
 
-char* FileRead::CString(Pos const pos) {
+char* FileRead::c_string(Pos const pos) {
 	assert(data_);
 
-	Pos i = pos.isNull() ? filepos_ : pos;
+	Pos i = pos.is_null() ? filepos_ : pos;
 	if (i >= length_)
 		throw FileBoundaryExceeded();
 	char* const result = data_ + i;
@@ -101,17 +101,17 @@
 	++i;                   //  beyond the null
 	if (i > (length_ + 1))  // allow EOF as end marker for string
 		throw FileBoundaryExceeded();
-	if (pos.isNull())
+	if (pos.is_null())
 		filepos_ = i;
 	return result;
 }
 
-char const* FileRead::CString() {
-	return CString(Pos::Null());
+char const* FileRead::c_string() {
+	return c_string(Pos::null());
 }
 
-char* FileRead::ReadLine() {
-	if (EndOfFile())
+char* FileRead::read_line() {
+	if (end_of_file())
 		return nullptr;
 	char* result = data_ + filepos_;
 	for (; data_[filepos_] && data_[filepos_] != '\n'; ++filepos_)

=== modified file 'src/io/fileread.h'
--- src/io/fileread.h	2014-09-09 17:15:20 +0000
+++ src/io/fileread.h	2014-09-29 14:39:47 +0000
@@ -40,12 +40,12 @@
 		Pos(size_t const p = 0) : pos(p) {
 		}
 		/// Returns a special value indicating invalidity.
-		static Pos Null() {
+		static Pos null() {
 			return std::numeric_limits<size_t>::max();
 		}
 
-		bool isNull() const {
-			return *this == Null();
+		bool is_null() const {
+			return *this == null();
 		}
 		operator size_t() const {
 			return pos;
@@ -72,45 +72,45 @@
 	~FileRead() override;
 
 	// See base class.
-	size_t Data(void* dst, size_t bufsize) override;
-	bool EndOfFile() const override;
-	char const* CString() override;
+	size_t data(void* dst, size_t bufsize) override;
+	bool end_of_file() const override;
+	char const* c_string() override;
 
 	/// Loads a file into memory. Reserves one additional byte which is zeroed,
 	/// so that text files can be handled like a null-terminated string.
 	/// \throws an exception if the file couldn't be loaded for whatever reason.
 
 	// TODO(unknown): error handling
-	void Open(FileSystem& fs, const std::string& filename);
+	void open(FileSystem& fs, const std::string& filename);
 
-	/// Works just like Open, but returns false when the load fails.
-	// TODO(sirver): This method can be expressed through Open() and should not
+	/// Works just like open, but returns false when the load fails.
+	// TODO(sirver): This method can be expressed through open() and should not
 	// be part of the public API, rather a stand alone function.
-	bool TryOpen(FileSystem& fs, const std::string& filename);
+	bool try_open(FileSystem& fs, const std::string& filename);
 
 	/// Frees allocated memory.
-	void Close();
+	void close();
 
 	// Returns the size of the file in bytes;
-	size_t GetSize() const;
+	size_t get_size() const;
 
 	/// Set the file pointer to the given location.
 	/// \throws File_Boundary_Exceeded if the pointer is out of bound.
-	void SetFilePos(Pos pos);
+	void set_file_pos(Pos pos);
 
 	/// Get the position that will be read from in the next read operation that
 	/// does not specify a position.
-	Pos GetPos() const;
+	Pos get_pos() const;
 
 	// Returns the next 'bytes' starting at 'pos' in the file. Can throw
 	// File_Boundary_Exceeded.
-	char* Data(uint32_t bytes, Pos pos = Pos::Null());
+	char* data(uint32_t bytes, Pos pos = Pos::null());
 
 	// Returns the whole file as a string starting from 'pos'.
-	char* CString(Pos pos);
+	char* c_string(Pos pos);
 
 	// Returns the next line.
-	char* ReadLine();
+	char* read_line();
 
 private:
 	char* data_;

=== modified file 'src/io/filesystem/disk_filesystem.cc'
--- src/io/filesystem/disk_filesystem.cc	2014-09-14 11:31:58 +0000
+++ src/io/filesystem/disk_filesystem.cc	2014-09-29 14:39:47 +0000
@@ -71,22 +71,22 @@
 : m_directory(Directory)
 {
 	// TODO(unknown): check OS permissions on whether the directory is writable!
-	m_root = FS_CanonicalizeName(Directory);
+	m_root = canonicalize_name(Directory);
 }
 
 
 /**
  * SHOULD return true if this directory is writable.
  */
-bool RealFSImpl::IsWritable() const {
+bool RealFSImpl::is_writable() const {
 	// Should be checked here (ondisk state can change)
 	return true;
 }
 
 /// returns true, if the file is writeable
-bool RealFSImpl::FileIsWriteable(const std::string & path) {
+bool RealFSImpl::file_is_writeable(const std::string & path) {
 	std::string fullname;
-	fullname = FS_CanonicalizeName(path);
+	fullname = canonicalize_name(path);
 
 	// we call fopen with "a" == append to be sure nothing gets overwritten
 	FILE * const f = fopen(fullname.c_str(), "a");
@@ -97,7 +97,7 @@
 }
 
 
-std::set<std::string> RealFSImpl::ListDirectory(const std::string & path)
+std::set<std::string> RealFSImpl::list_directory(const std::string & path)
 {
 #ifdef _WIN32
 	std::string buf;
@@ -124,7 +124,7 @@
 		if ((strcmp(c_file.name, ".") == 0) || (strcmp(c_file.name, "..") == 0)) {
 			continue;
 		}
-		const std::string filename = FS_CanonicalizeName(realpath + c_file.name);
+		const std::string filename = canonicalize_name(realpath + c_file.name);
 		const std::string result = filename.substr(m_root.size() + 1);
 		results.insert(result);
 	} while (_findnext(hFile, &c_file) == 0);
@@ -138,7 +138,7 @@
 	int32_t ofs;
 
 	if (path.size()) {
-		if (pathIsAbsolute(path)) {
+		if (is_path_absolute(path)) {
 			buf = path + "/*";
 			ofs = 0;
 		} else {
@@ -155,7 +155,7 @@
 		return results;
 
 	for (size_t i = 0; i < gl.gl_pathc; ++i) {
-		const std::string filename(FS_CanonicalizeName(&gl.gl_pathv[i][ofs]));
+		const std::string filename(canonicalize_name(&gl.gl_pathv[i][ofs]));
 		results.insert(filename.substr(m_root.size() + 1));
 	}
 
@@ -171,8 +171,8 @@
  * \e can't exist then)
  */
 // TODO(unknown): Can this be rewritten to just using exceptions? Should it?
-bool RealFSImpl::FileExists(const std::string & path) {
-	return FileSystemPath(FS_CanonicalizeName(path)).m_exists;
+bool RealFSImpl::file_exists(const std::string & path) {
+	return FileSystemPath(canonicalize_name(path)).m_exists;
 }
 
 /**
@@ -180,15 +180,15 @@
  * Also returns false if the pathname is invalid (obviously, because the file
  * \e can't exist then)
  */
-bool RealFSImpl::IsDirectory(const std::string & path) {
-	return FileSystemPath(FS_CanonicalizeName(path)).m_isDirectory;
+bool RealFSImpl::is_directory(const std::string & path) {
+	return FileSystemPath(canonicalize_name(path)).m_isDirectory;
 }
 
 /**
  * Create a sub filesystem out of this filesystem
  */
-FileSystem * RealFSImpl::MakeSubFileSystem(const std::string & path) {
-	FileSystemPath fspath(FS_CanonicalizeName(path));
+FileSystem * RealFSImpl::make_sub_file_system(const std::string & path) {
+	FileSystemPath fspath(canonicalize_name(path));
 	assert(fspath.m_exists); //TODO(unknown): throw an exception instead
 
 	if (fspath.m_isDirectory)
@@ -200,16 +200,16 @@
 /**
  * Create a sub filesystem out of this filesystem
  */
-FileSystem * RealFSImpl::CreateSubFileSystem(const std::string & path, Type const fs)
+FileSystem * RealFSImpl::create_sub_file_system(const std::string & path, Type const fs)
 {
-	FileSystemPath fspath(FS_CanonicalizeName(path));
+	FileSystemPath fspath(canonicalize_name(path));
 	if (fspath.m_exists)
 		throw wexception
 			("path %s already exists, can not create a filesystem from it",
 			 path.c_str());
 
 	if (fs == FileSystem::DIR) {
-		EnsureDirectoryExists(path);
+		ensure_directory_exists(path);
 		return new RealFSImpl(fspath);
 	} else
 		return new ZipFilesystem(fspath);
@@ -218,8 +218,8 @@
 /**
  * Remove a number of files
  */
-void RealFSImpl::Unlink(const std::string & file) {
-	FileSystemPath fspath(FS_CanonicalizeName(file));
+void RealFSImpl::fs_unlink(const std::string & file) {
+	FileSystemPath fspath(canonicalize_name(file));
 	if (!fspath.m_exists)
 		return;
 
@@ -233,14 +233,14 @@
  * Remove a single directory or file
  */
 void RealFSImpl::m_unlink_file(const std::string & file) {
-	FileSystemPath fspath(FS_CanonicalizeName(file));
+	FileSystemPath fspath(canonicalize_name(file));
 	assert(fspath.m_exists);  //TODO(unknown): throw an exception instead
 	assert(!fspath.m_isDirectory); //TODO(unknown): throw an exception instead
 
 #ifndef _WIN32
 	unlink(fspath.c_str());
 #else
-	DeleteFile(fspath.c_str());
+	delete_file(fspath.c_str());
 #endif
 }
 
@@ -248,23 +248,23 @@
  * Recursively remove a directory
  */
 void RealFSImpl::m_unlink_directory(const std::string & file) {
-	FileSystemPath fspath(FS_CanonicalizeName(file));
+	FileSystemPath fspath(canonicalize_name(file));
 	assert(fspath.m_exists);  //TODO(unknown): throw an exception instead
 	assert(fspath.m_isDirectory);  //TODO(unknown): throw an exception instead
 
-	FilenameSet files = ListDirectory(file);
+	FilenameSet files = list_directory(file);
 	for
 		(FilenameSet::iterator pname = files.begin();
 		 pname != files.end();
 		 ++pname)
 	{
-		std::string filename = FS_Filename(pname->c_str());
+		std::string filename = fs_filename(pname->c_str());
 		if (filename == "..")
 			continue;
 		if (filename == ".")
 			continue;
 
-		if (IsDirectory(*pname))
+		if (is_directory(*pname))
 			m_unlink_directory(*pname);
 		else
 			m_unlink_file(*pname);
@@ -275,7 +275,7 @@
 #ifndef _WIN32
 	rmdir(fspath.c_str());
 #else
-	RemoveDirectory(fspath.c_str());
+	remove_directory(fspath.c_str());
 #endif
 }
 
@@ -283,20 +283,20 @@
  * Create this directory if it doesn't exist, throws an error
  * if the dir can't be created or if a file with this name exists
  */
-void RealFSImpl::EnsureDirectoryExists(const std::string & dirname)
+void RealFSImpl::ensure_directory_exists(const std::string & dirname)
 {
 	try {
 		std::string::size_type it = 0;
 		while (it < dirname.size()) {
 			it = dirname.find(m_filesep, it);
 
-			FileSystemPath fspath(FS_CanonicalizeName(dirname.substr(0, it)));
+			FileSystemPath fspath(canonicalize_name(dirname.substr(0, it)));
 			if (fspath.m_exists && !fspath.m_isDirectory)
 				throw wexception
 					("%s exists and is not a directory",
 					 dirname.substr(0, it).c_str());
 			if (!fspath.m_exists)
-				MakeDirectory(dirname.substr(0, it));
+				make_directory(dirname.substr(0, it));
 
 			if (it == std::string::npos)
 				break;
@@ -304,7 +304,7 @@
 		}
 	} catch (const std::exception & e) {
 		throw wexception
-			("RealFSImpl::EnsureDirectoryExists(%s): %s",
+			("RealFSImpl::ensure_directory_exists(%s): %s",
 			 dirname.c_str(), e.what());
 	}
 }
@@ -314,11 +314,11 @@
  * if a file is in the way or if the creation fails.
  *
  * Pleas note, this function does not honor parents,
- * MakeDirectory("onedir/otherdir/onemoredir") will fail
+ * make_directory("onedir/otherdir/onemoredir") will fail
  * if either onedir or otherdir is missing
  */
-void RealFSImpl::MakeDirectory(const std::string & dirname) {
-	FileSystemPath fspath(FS_CanonicalizeName(dirname));
+void RealFSImpl::make_directory(const std::string & dirname) {
+	FileSystemPath fspath(canonicalize_name(dirname));
 	if (fspath.m_exists)
 		throw wexception
 			("a file with the name \"%s\" already exists", dirname.c_str());
@@ -333,19 +333,19 @@
 		 ==
 		 -1)
 		throw DirectoryCannotCreateError
-			("RealFSImpl::MakeDirectory",
+			("RealFSImpl::make_directory",
 			 dirname,
 			 strerror(errno));
 }
 
 /**
- * Read the given file into alloced memory; called by FileRead::Open.
+ * Read the given file into alloced memory; called by FileRead::open.
  * Throws an exception if the file couldn't be opened.
  */
-void * RealFSImpl::Load(const std::string & fname, size_t & length) {
-	const std::string fullname = FS_CanonicalizeName(fname);
-	if (IsDirectory(fullname)) {
-		throw FileError("RealFSImpl::Load", fullname.c_str());
+void * RealFSImpl::load(const std::string & fname, size_t & length) {
+	const std::string fullname = canonicalize_name(fname);
+	if (is_directory(fullname)) {
+		throw FileError("RealFSImpl::load", fullname.c_str());
 	}
 
 	FILE * file = nullptr;
@@ -354,7 +354,7 @@
 	try {
 		file = fopen(fullname.c_str(), "rb");
 		if (!file)
-			throw FileError("RealFSImpl::Load", fullname.c_str());
+			throw FileError("RealFSImpl::load", fullname.c_str());
 
 		// determine the size of the file (rather quirky, but it doesn't require
 		// potentially unportable functions)
@@ -364,7 +364,7 @@
 			const int32_t ftell_pos = ftell(file);
 			if (ftell_pos < 0)
 				throw wexception
-					("RealFSImpl::Load: error when loading \"%s\" (\"%s\"): file "
+					("RealFSImpl::load: error when loading \"%s\" (\"%s\"): file "
 					 "size calculation yielded negative value %i",
 					 fname.c_str(), fullname.c_str(), ftell_pos);
 			size = ftell_pos;
@@ -376,7 +376,7 @@
 		int result = fread(data, size, 1, file);
 		if (size && (result != 1)) {
 			throw wexception
-				("RealFSImpl::Load: read failed for %s (%s) with size %" PRIuS "",
+				("RealFSImpl::load: read failed for %s (%s) with size %" PRIuS "",
 				 fname.c_str(), fullname.c_str(), size);
 		}
 		static_cast<int8_t *>(data)[size] = 0;
@@ -402,11 +402,11 @@
  * that file.
  * Throws an exception if it fails.
  */
-void RealFSImpl::Write(const std::string & fname, void const * const data, int32_t const length, bool append)
+void RealFSImpl::write(const std::string & fname, void const * const data, int32_t const length, bool append)
 {
 	std::string fullname;
 
-	fullname = FS_CanonicalizeName(fname);
+	fullname = canonicalize_name(fname);
 
 	FILE * const f = fopen(fullname.c_str(), append ? "a" : "wb");
 	if (!f)
@@ -422,11 +422,11 @@
 }
 
 // rename a file or directory
-void RealFSImpl::Rename
+void RealFSImpl::fs_rename
 	(const std::string & old_name, const std::string & new_name)
 {
-	const std::string fullname1 = FS_CanonicalizeName(old_name);
-	const std::string fullname2 = FS_CanonicalizeName(new_name);
+	const std::string fullname1 = canonicalize_name(old_name);
+	const std::string fullname2 = canonicalize_name(new_name);
 	rename(fullname1.c_str(), fullname2.c_str());
 }
 
@@ -452,11 +452,11 @@
 		fclose(m_file);
 	}
 
-	size_t Data(void * data, size_t const bufsize) override {
-		return fread(data, 1, bufsize, m_file);
+	size_t data(void * read_data, size_t const bufsize) override {
+		return fread(read_data, 1, bufsize, m_file);
 	}
 
-	bool EndOfFile() const override
+	bool end_of_file() const override
 	{
 		return feof(m_file);
 	}
@@ -467,8 +467,8 @@
 
 }
 
-StreamRead * RealFSImpl::OpenStreamRead(const std::string & fname) {
-	const std::string fullname = FS_CanonicalizeName(fname);
+StreamRead * RealFSImpl::open_stream_read(const std::string & fname) {
+	const std::string fullname = canonicalize_name(fname);
 
 	return new RealFSStreamRead(fullname);
 }
@@ -493,15 +493,15 @@
 
 	~RealFSStreamWrite() {fclose(m_file);}
 
-	void Data(const void * const data, const size_t size) override
+	void data(const void * const write_data, const size_t size) override
 	{
-		size_t ret = fwrite(data, 1, size, m_file);
+		size_t ret = fwrite(write_data, 1, size, m_file);
 
 		if (ret != size)
 			throw wexception("Write to %s failed", m_filename.c_str());
 	}
 
-	void Flush() override
+	void flush() override
 	{
 		fflush(m_file);
 	}
@@ -513,25 +513,25 @@
 
 }
 
-StreamWrite * RealFSImpl::OpenStreamWrite(const std::string & fname) {
-	const std::string fullname = FS_CanonicalizeName(fname);
+StreamWrite * RealFSImpl::open_stream_write(const std::string & fname) {
+	const std::string fullname = canonicalize_name(fname);
 
 	return new RealFSStreamWrite(fullname);
 }
 
-unsigned long long RealFSImpl::DiskSpace() {
+unsigned long long RealFSImpl::disk_space() {
 #ifdef _WIN32
 	ULARGE_INTEGER freeavailable;
 	return
 		GetDiskFreeSpaceEx
-			(FS_CanonicalizeName(m_directory).c_str(), &freeavailable, 0, 0)
+			(canonicalize_name(m_directory).c_str(), &freeavailable, 0, 0)
 		?
 		//if more than 2G free space report that much
 		freeavailable.HighPart ? std::numeric_limits<unsigned long>::max() :
 		freeavailable.LowPart : 0;
 #else
 	struct statvfs svfs;
-	if (statvfs(FS_CanonicalizeName(m_directory).c_str(), &svfs) != -1) {
+	if (statvfs(canonicalize_name(m_directory).c_str(), &svfs) != -1) {
 		return static_cast<unsigned long long>(svfs.f_bsize) * svfs.f_bavail;
 	}
 #endif

=== modified file 'src/io/filesystem/disk_filesystem.h'
--- src/io/filesystem/disk_filesystem.h	2014-07-26 10:43:23 +0000
+++ src/io/filesystem/disk_filesystem.h	2014-09-29 14:39:47 +0000
@@ -30,32 +30,32 @@
 public:
 	RealFSImpl(const std::string & Directory);
 
-	std::set<std::string> ListDirectory(const std::string& path) override;
-
-	bool IsWritable() const override;
-	bool FileIsWriteable(const std::string & path);
-	bool FileExists (const std::string & path) override;
-	bool IsDirectory(const std::string & path) override;
-	void EnsureDirectoryExists(const std::string & dirname) override;
-	void MakeDirectory        (const std::string & dirname) override;
-
-	void * Load(const std::string & fname, size_t & length) override;
-
-
-	void Write(const std::string & fname, void const * data, int32_t length, bool append);
-	void Write(const std::string & fname, void const * data, int32_t length) override
-		{Write(fname, data, length, false);}
-
-	StreamRead  * OpenStreamRead (const std::string & fname) override;
-	StreamWrite * OpenStreamWrite(const std::string & fname) override;
-
-	FileSystem * MakeSubFileSystem(const std::string & dirname) override;
-	FileSystem * CreateSubFileSystem(const std::string & dirname, Type) override;
-	void Unlink(const std::string & file) override;
-	void Rename(const std::string & old_name, const std::string & new_name) override;
-
-	std::string getBasename() override {return m_directory;}
-	unsigned long long DiskSpace() override;
+	std::set<std::string> list_directory(const std::string& path) override;
+
+	bool is_writable() const override;
+	bool file_is_writeable(const std::string & path);
+	bool file_exists (const std::string & path) override;
+	bool is_directory(const std::string & path) override;
+	void ensure_directory_exists(const std::string & fs_dirname) override;
+	void make_directory        (const std::string & fs_dirname) override;
+
+	void * load(const std::string & fname, size_t & length) override;
+
+
+	void write(const std::string & fname, void const * data, int32_t length, bool append);
+	void write(const std::string & fname, void const * data, int32_t length) override
+		{write(fname, data, length, false);}
+
+	StreamRead  * open_stream_read (const std::string & fname) override;
+	StreamWrite * open_stream_write(const std::string & fname) override;
+
+	FileSystem * make_sub_file_system(const std::string & fs_dirname) override;
+	FileSystem * create_sub_file_system(const std::string & fs_dirname, Type) override;
+	void fs_unlink(const std::string & file) override;
+	void fs_rename(const std::string & old_name, const std::string & new_name) override;
+
+	std::string get_basename() override {return m_directory;}
+	unsigned long long disk_space() override;
 
 private:
 	void m_unlink_directory(const std::string & file);

=== modified file 'src/io/filesystem/filesystem.cc'
--- src/io/filesystem/filesystem.cc	2014-09-10 13:03:40 +0000
+++ src/io/filesystem/filesystem.cc	2014-09-29 14:39:47 +0000
@@ -75,7 +75,7 @@
  * \param path A file or directory name
  * \return True if ref path is absolute and within this FileSystem, false otherwise
  */
-bool FileSystem::pathIsAbsolute(const std::string & path) const {
+bool FileSystem::is_path_absolute(const std::string & path) const {
 	std::string::size_type const path_size = path  .size();
 	std::string::size_type const root_size = m_root.size();
 
@@ -107,7 +107,7 @@
  * This function is used to make sure that paths send via network are usable
  * on locale OS.
  */
-std::string FileSystem::fixCrossFile(const std::string & path) const {
+std::string FileSystem::fix_cross_file(const std::string & path) const {
 	uint32_t path_size = path.size();
 	std::string fixedPath(path);
 	std::string temp;
@@ -141,18 +141,18 @@
 /**
  * \return The process' current working directory
  */
-std::string FileSystem::getWorkingDirectory() const {
+std::string FileSystem::get_working_directory() const {
 	char cwd[PATH_MAX + 1];
 	char * const result = getcwd(cwd, PATH_MAX);
 	if (! result)
-		throw FileError("FileSystem::getWorkingDirectory()", "widelands", "can not run getcwd");
+		throw FileError("FileSystem::get_working_directory()", "widelands", "can not run getcwd");
 
 	return std::string(cwd);
 }
 
 
 // TODO(unknown): Write homedir detection for non-getenv-systems
-std::string FileSystem::GetHomedir()
+std::string FileSystem::get_homedir()
 {
 	std::string homedir;
 #ifdef _WIN32
@@ -199,7 +199,7 @@
  * \param components The output iterator to place the path nodes into
  */
 template<typename Inserter>
-static void FS_Tokenize
+static void fs_tokenize
 	(const std::string & path, char const filesep, Inserter components)
 {
 	std::string::size_type pos;  //  start of token
@@ -234,7 +234,7 @@
  * Transform any valid, unique pathname into a well-formed absolute path
  */
 // TODO(unknown): Enable non-Unix paths
-std::string FileSystem::FS_CanonicalizeName(std::string path) const {
+std::string FileSystem::canonicalize_name(std::string path) const {
 	std::list<std::string> components;
 	std::list<std::string>::iterator i;
 
@@ -246,19 +246,19 @@
 	}
 #endif
 
-	FS_Tokenize(path, m_filesep, std::inserter(components, components.begin()));
+	fs_tokenize(path, m_filesep, std::inserter(components, components.begin()));
 
 	//tilde expansion
 	if (!components.empty() && *components.begin() == "~") {
 		components.erase(components.begin());
-		FS_Tokenize
-			(GetHomedir(),
+		fs_tokenize
+			(get_homedir(),
 			 m_filesep,
 			 std::inserter(components, components.begin()));
-	} else if (!pathIsAbsolute(path))
+	} else if (!is_path_absolute(path))
 		//  make relative paths absolute (so that "../../foo" can work)
-		FS_Tokenize
-			(m_root.empty() ? getWorkingDirectory() : m_root, m_filesep,
+		fs_tokenize
+			(m_root.empty() ? get_working_directory() : m_root, m_filesep,
 			 std::inserter(components, components.begin()));
 
 	//clean up the path
@@ -316,7 +316,7 @@
  * Returns the filename of this path, everything after the last
  * / or \  (or the whole string)
  */
-const char * FileSystem::FS_Filename(const char * p) {
+const char * FileSystem::fs_filename(const char * p) {
 	const char * result = p;
 
 	while (*p != '\0') {
@@ -328,12 +328,12 @@
 	return result;
 }
 
-std::string FileSystem::FS_Dirname(const std::string& full_path) {
-	const std::string filename = FS_Filename(full_path.c_str());
+std::string FileSystem::fs_dirname(const std::string& full_path) {
+	const std::string filename = fs_filename(full_path.c_str());
 	return full_path.substr(0, full_path.size() - filename.size());
 }
 
-std::string FileSystem::FS_FilenameExt(const std::string & f)
+std::string FileSystem::filename_ext(const std::string & f)
 {
 	// Find last '.' - denotes start of extension
 	size_t ext_start = f.rfind('.');
@@ -344,10 +344,10 @@
 		return f.substr(ext_start);
 }
 
-std::string FileSystem::FS_FilenameWoExt(const char * const p)
+std::string FileSystem::filename_without_ext(const char * const p)
 {
-	std::string fname(p ? FileSystem::FS_Filename(p) : "");
-	std::string ext(FileSystem::FS_FilenameExt(fname));
+	std::string fname(p ? FileSystem::fs_filename(p) : "");
+	std::string ext(FileSystem::filename_ext(fname));
 	return fname.substr(0, fname.length() - ext.length());
 }
 
@@ -361,7 +361,7 @@
 // TODO(unknown): Catch FileNotFoundError in all users
 // TODO(unknown): throw FileTypeError if root is not a zipfile (exception from
 // ZipFilesystem)
-FileSystem & FileSystem::Create(const std::string & root)
+FileSystem & FileSystem::create(const std::string & root)
 {
 	struct stat statinfo;
 
@@ -375,10 +375,10 @@
 #endif
 			 errno == ENAMETOOLONG)
 		{
-			throw FileNotFoundError("FileSystem::Create", root);
+			throw FileNotFoundError("FileSystem::create", root);
 		}
 		if (errno == EACCES)
-			throw FileAccessDeniedError("FileSystem::Create", root);
+			throw FileAccessDeniedError("FileSystem::create", root);
 	}
 
 	if (S_ISDIR(statinfo.st_mode)) {
@@ -389,7 +389,7 @@
 	}
 
 	throw FileTypeError
-		("FileSystem::Create", root,
+		("FileSystem::create", root,
 		 "cannot create virtual filesystem from file or directory");
 }
 
@@ -400,12 +400,12 @@
 {
 	RealFSImpl fs(path);
 
-	if (fs.IsDirectory(".widelands"))
+	if (fs.is_directory(".widelands"))
 		return true;
 	try {
 		// throws an exception if not writable
-		fs.EnsureDirectoryExists(".widelands");
-		fs.Unlink(".widelands");
+		fs.ensure_directory_exists(".widelands");
+		fs.unlink(".widelands");
 		return true;
 	} catch (...) {
 		log("Directory %s is not writeable - next try\n", path);

=== modified file 'src/io/filesystem/filesystem.h'
--- src/io/filesystem/filesystem.h	2014-09-14 11:31:58 +0000
+++ src/io/filesystem/filesystem.h	2014-09-29 14:39:47 +0000
@@ -53,20 +53,20 @@
 	virtual ~FileSystem() {}
 
 	// Returns all files and directories (full path) in the given directory 'directory'.
-	virtual std::set<std::string> ListDirectory(const std::string& directory) = 0;
-
-	virtual bool IsWritable() const = 0;
-	virtual bool IsDirectory(const std::string & path) = 0;
-	virtual bool FileExists (const std::string & path) = 0;
-
-	virtual void * Load(const std::string & fname, size_t & length) = 0;
-
-	virtual void Write
+	virtual std::set<std::string> list_directory(const std::string& directory) = 0;
+
+	virtual bool is_writable() const = 0;
+	virtual bool is_directory(const std::string & path) = 0;
+	virtual bool file_exists (const std::string & path) = 0;
+
+	virtual void * load(const std::string & fname, size_t & length) = 0;
+
+	virtual void write
 		(const std::string & fname, void const * data, int32_t length)
 		= 0;
-	virtual void EnsureDirectoryExists(const std::string & dirname) = 0;
-	//TODO(unknown): use this only from inside EnsureDirectoryExists()
-	virtual void MakeDirectory(const std::string & dirname) = 0;
+	virtual void ensure_directory_exists(const std::string & fs_dirname) = 0;
+	//TODO(unknown): use this only from inside ensure_directory_exists()
+	virtual void make_directory(const std::string & fs_dirname) = 0;
 
 	/**
 	 * Opens the given file for reading as a stream.
@@ -75,7 +75,7 @@
 	 * \return a \ref StreamRead object for the file. The caller must delete this
 	 * object when done to close the file.
 	 */
-	virtual StreamRead * OpenStreamRead(const std::string & fname) = 0;
+	virtual StreamRead * open_stream_read(const std::string & fname) = 0;
 
 	/**
 	 * Opens the given file for writing as a stream.
@@ -87,47 +87,47 @@
 	 * delete this object when done to close the file (which will implicitly
 	 * flush unwritten data).
 	 */
-	virtual StreamWrite * OpenStreamWrite(const std::string & fname) = 0;
+	virtual StreamWrite * open_stream_write(const std::string & fname) = 0;
 
 	/**
 	 * Creates a subfilesystem from an existing file/directory.
 	 * Passes ownership to caller.
 	 */
-	virtual FileSystem * MakeSubFileSystem(const std::string & dirname) = 0;
+	virtual FileSystem * make_sub_file_system(const std::string & fs_dirname) = 0;
 	/**
 	 * Creates a subfilesystem from a new file/directory.
 	 * Passes ownership to caller.
 	 */
-	virtual FileSystem * CreateSubFileSystem(const std::string & dirname, Type) = 0;
-	virtual void Unlink(const std::string &) = 0;
-	virtual void Rename(const std::string &, const std::string &) = 0;
+	virtual FileSystem * create_sub_file_system(const std::string & fs_dirname, Type) = 0;
+	virtual void fs_unlink(const std::string &) = 0;
+	virtual void fs_rename(const std::string &, const std::string &) = 0;
 
-	static FileSystem & Create(const std::string & root)
+	static FileSystem & create(const std::string & root)
 ;
 
 	///Retrieve the filesystem root's name == the mountpoint inside a
 	///LayeredFileSystem
-	virtual std::string getBasename() = 0;
+	virtual std::string get_basename() = 0;
 
 	// basic path/filename manipulation
-	std::string fixCrossFile(const std::string &) const;
-	char fileSeparator() {return m_filesep;}
-	std::string getWorkingDirectory() const;
-	std::string FS_CanonicalizeName(std::string path) const;
-	bool pathIsAbsolute(const std::string & path) const;
+	std::string fix_cross_file(const std::string &) const;
+	char file_separator() {return m_filesep;}
+	std::string get_working_directory() const;
+	std::string canonicalize_name(std::string path) const;
+	bool is_path_absolute(const std::string & path) const;
 
 	///Given a filename, return the name with any path stripped off.
-	static const char * FS_Filename(const char * n);
-	static std::string FS_Dirname(const std::string& full_path);
+	static const char * fs_filename(const char * n);
+	static std::string fs_dirname(const std::string& full_path);
 
 	///Given a filename (without any path), return the extension, if any.
-	static std::string FS_FilenameExt(const std::string & f);
+	static std::string filename_ext(const std::string & f);
 
 	///Given a filename, return the name with any path or extension stripped off.
-	static std::string FS_FilenameWoExt(const char * n);
-	static std::string GetHomedir();
+	static std::string filename_without_ext(const char * n);
+	static std::string get_homedir();
 
-	virtual unsigned long long DiskSpace() = 0;
+	virtual unsigned long long disk_space() = 0;
 
 protected:
 	///To get a filesystem, use the Create methods

=== modified file 'src/io/filesystem/layered_filesystem.cc'
--- src/io/filesystem/layered_filesystem.cc	2014-09-14 11:31:58 +0000
+++ src/io/filesystem/layered_filesystem.cc	2014-09-29 14:39:47 +0000
@@ -43,15 +43,15 @@
  * Just assume that at least one of our child FSs is writable
  */
 // TODO(unknown): Implement me
-bool LayeredFileSystem::IsWritable() const {
+bool LayeredFileSystem::is_writable() const {
 	return true;
 }
 
-void LayeredFileSystem::AddFileSystem(FileSystem* fs) {
+void LayeredFileSystem::add_file_system(FileSystem* fs) {
 	m_filesystems.emplace_back(fs);
 }
 
-void LayeredFileSystem::SetHomeFileSystem(FileSystem * fs)
+void LayeredFileSystem::set_home_file_system(FileSystem * fs)
 {
 	m_home.reset(fs);
 }
@@ -60,11 +60,11 @@
  * Remove a filesystem from the stack
  * \param fs The filesystem to be removed
  */
-void LayeredFileSystem::RemoveFileSystem(const FileSystem & fs)
+void LayeredFileSystem::remove_file_system(const FileSystem & fs)
 {
 	if (m_filesystems.back().get() != &fs)
 		throw std::logic_error
-			("LayeredFileSystem::RemoveFileSystem: interspersed add/remove "
+			("LayeredFileSystem::remove_file_system: interspersed add/remove "
 			 "detected!");
 	m_filesystems.pop_back();
 }
@@ -77,12 +77,12 @@
  *
  * Returns the number of files found.
  */
-std::set<std::string> LayeredFileSystem::ListDirectory(const std::string& path) {
+std::set<std::string> LayeredFileSystem::list_directory(const std::string& path) {
 	std::set<std::string> results;
 	FilenameSet files;
 	//check home system first
 	if (m_home) {
-		files = m_home->ListDirectory(path);
+		files = m_home->list_directory(path);
 		for
 			(FilenameSet::iterator fnit = files.begin();
 			 fnit != files.end();
@@ -91,7 +91,7 @@
 	}
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it) {
-		files = (*it)->ListDirectory(path);
+		files = (*it)->list_directory(path);
 
 		for (FilenameSet::iterator fnit = files.begin(); fnit != files.end(); ++fnit)
 			   results.insert(*fnit);
@@ -102,11 +102,11 @@
 /**
  * Returns true if the file can be found in at least one of the sub-filesystems
  */
-bool LayeredFileSystem::FileExists(const std::string & path) {
-	if (m_home && m_home->FileExists(path))
+bool LayeredFileSystem::file_exists(const std::string & path) {
+	if (m_home && m_home->file_exists(path))
 		return true;
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->FileExists(path))
+		if ((*it)->file_exists(path))
 			return true;
 
 	return false;
@@ -116,32 +116,32 @@
  * Returns true if path is a directory in at least one of the directories
  */
 // TODO(unknown): What if it's a file in some and a dir in others?????
-bool LayeredFileSystem::IsDirectory(const std::string & path) {
-	if (m_home && m_home->IsDirectory(path))
+bool LayeredFileSystem::is_directory(const std::string & path) {
+	if (m_home && m_home->is_directory(path))
 		return true;
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsDirectory(path))
+		if ((*it)->is_directory(path))
 			return true;
 
 	return false;
 }
 
 /**
- * Read the given file into alloced memory; called by FileRead::Open.
+ * Read the given file into alloced memory; called by FileRead::open.
  * Throws an exception if the file couldn't be opened.
  *
  * Note: We first query the sub-filesystem whether the file exists. Otherwise,
  * we'd have problems differentiating the errors returned by the sub-FS.
  * Let's just avoid any possible hassles with that.
  */
-void * LayeredFileSystem::Load(const std::string & fname, size_t & length) {
-	if (m_home && m_home->FileExists(fname))
-		return m_home->Load(fname, length);
+void * LayeredFileSystem::load(const std::string & fname, size_t & length) {
+	if (m_home && m_home->file_exists(fname))
+		return m_home->load(fname, length);
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->FileExists(fname))
-			return (*it)->Load(fname, length);
+		if ((*it)->file_exists(fname))
+			return (*it)->load(fname, length);
 
 	throw FileNotFoundError("Could not find file", fname);
 }
@@ -150,15 +150,15 @@
  * Write the given block of memory out as a file to the first writable sub-FS.
  * Throws an exception if it fails.
  */
-void LayeredFileSystem::Write
+void LayeredFileSystem::write
 	(const std::string & fname, void const * const data, int32_t const length)
 {
-	if (m_home && m_home->IsWritable())
-		return m_home->Write(fname, data, length);
+	if (m_home && m_home->is_writable())
+		return m_home->write(fname, data, length);
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsWritable())
-			return (*it)->Write(fname, data, length);
+		if ((*it)->is_writable())
+			return (*it)->write(fname, data, length);
 
 	throw wexception("LayeredFileSystem: No writable filesystem!");
 }
@@ -167,13 +167,13 @@
  * Analogously to Read, open the file from the first sub-filesystem where
  * it exists.
  */
-StreamRead  * LayeredFileSystem::OpenStreamRead (const std::string & fname) {
-	if (m_home && m_home->FileExists(fname))
-		return m_home->OpenStreamRead(fname);
+StreamRead  * LayeredFileSystem::open_stream_read (const std::string & fname) {
+	if (m_home && m_home->file_exists(fname))
+		return m_home->open_stream_read(fname);
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->FileExists(fname))
-			return (*it)->OpenStreamRead(fname);
+		if ((*it)->file_exists(fname))
+			return (*it)->open_stream_read(fname);
 
 	throw FileNotFoundError("Could not find file", fname);
 }
@@ -181,13 +181,13 @@
 /**
  * Analogously to Write, create the file in the first writable sub-FS.
  */
-StreamWrite * LayeredFileSystem::OpenStreamWrite(const std::string & fname) {
-	if (m_home && m_home->IsWritable())
-		return m_home->OpenStreamWrite(fname);
+StreamWrite * LayeredFileSystem::open_stream_write(const std::string & fname) {
+	if (m_home && m_home->is_writable())
+		return m_home->open_stream_write(fname);
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsWritable())
-			return (*it)->OpenStreamWrite(fname);
+		if ((*it)->is_writable())
+			return (*it)->open_stream_write(fname);
 
 	throw wexception("LayeredFileSystem: No writable filesystem!");
 }
@@ -195,27 +195,27 @@
 /**
  * MakeDir in first writable directory
  */
-void LayeredFileSystem::MakeDirectory(const std::string & dirname) {
-	if (m_home && m_home->IsWritable())
-		return m_home->MakeDirectory(dirname);
+void LayeredFileSystem::make_directory(const std::string & dirname) {
+	if (m_home && m_home->is_writable())
+		return m_home->make_directory(dirname);
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsWritable())
-			return (*it)->MakeDirectory(dirname);
+		if ((*it)->is_writable())
+			return (*it)->make_directory(dirname);
 
 	throw wexception("LayeredFileSystem: No writable filesystem!");
 }
 
 /**
- * EnsureDirectoryExists in first writable directory
+ * ensure_directory_exists in first writable directory
  */
-void LayeredFileSystem::EnsureDirectoryExists(const std::string & dirname) {
-	if (m_home && m_home->IsWritable())
-		return m_home->EnsureDirectoryExists(dirname);
+void LayeredFileSystem::ensure_directory_exists(const std::string & dirname) {
+	if (m_home && m_home->is_writable())
+		return m_home->ensure_directory_exists(dirname);
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsWritable())
-			return (*it)->EnsureDirectoryExists(dirname);
+		if ((*it)->is_writable())
+			return (*it)->ensure_directory_exists(dirname);
 
 	throw wexception("LayeredFileSystem: No writable filesystem!");
 }
@@ -223,14 +223,14 @@
 /**
  * Create a subfilesystem from an existing file/directory
  */
-FileSystem * LayeredFileSystem::MakeSubFileSystem(const std::string & dirname)
+FileSystem * LayeredFileSystem::make_sub_file_system(const std::string & dirname)
 {
-	if (m_home && m_home->IsWritable() && m_home->FileExists(dirname))
-		return m_home->MakeSubFileSystem(dirname);
+	if (m_home && m_home->is_writable() && m_home->file_exists(dirname))
+		return m_home->make_sub_file_system(dirname);
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsWritable() && (*it)->FileExists(dirname))
-			return (*it)->MakeSubFileSystem(dirname);
+		if ((*it)->is_writable() && (*it)->file_exists(dirname))
+			return (*it)->make_sub_file_system(dirname);
 
 	throw wexception("LayeredFileSystem: unable to create sub filesystem");
 }
@@ -238,14 +238,14 @@
 /**
  * Create a subfilesystem from a new file/directory
  */
-FileSystem * LayeredFileSystem::CreateSubFileSystem(const std::string & dirname, Type const type)
+FileSystem * LayeredFileSystem::create_sub_file_system(const std::string & dirname, Type const type)
 {
-	if (m_home && m_home->IsWritable() && !m_home->FileExists(dirname))
-		return m_home->CreateSubFileSystem(dirname, type);
+	if (m_home && m_home->is_writable() && !m_home->file_exists(dirname))
+		return m_home->create_sub_file_system(dirname, type);
 
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsWritable() && !(*it)->FileExists(dirname))
-			return (*it)->CreateSubFileSystem(dirname, type);
+		if ((*it)->is_writable() && !(*it)->file_exists(dirname))
+			return (*it)->create_sub_file_system(dirname, type);
 
 	throw wexception("LayeredFileSystem: unable to create sub filesystem");
 }
@@ -253,33 +253,34 @@
 /**
  * Remove this file or directory. If it is a directory, remove it recursively
  */
-void LayeredFileSystem::Unlink(const std::string & file) {
-	if (!FileExists(file))
+void LayeredFileSystem::fs_unlink(const std::string & file) {
+	if (!file_exists(file))
 		return;
 
-	if (m_home && m_home->IsWritable() && m_home->FileExists(file)) {
-		m_home->Unlink(file);
+	if (m_home && m_home->is_writable() && m_home->file_exists(file)) {
+		m_home->fs_unlink(file);
 		return;
 	}
+
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsWritable() && (*it)->FileExists(file)) {
-			(*it)->Unlink(file);
+		if ((*it)->is_writable() && (*it)->file_exists(file)) {
+			(*it)->fs_unlink(file);
 			return;
 		}
 }
 
-void LayeredFileSystem::Rename
+void LayeredFileSystem::fs_rename
 	(const std::string & old_name, const std::string & new_name)
 {
-	if (!FileExists(old_name))
+	if (!file_exists(old_name))
 		return;
-	if (m_home && m_home->IsWritable() && m_home->FileExists(old_name)) {
-		m_home->Rename(old_name, new_name);
+	if (m_home && m_home->is_writable() && m_home->file_exists(old_name)) {
+		m_home->fs_rename(old_name, new_name);
 		return;
 	}
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
-		if ((*it)->IsWritable() && (*it)->FileExists(old_name)) {
-			(*it)->Rename(old_name, new_name);
+		if ((*it)->is_writable() && (*it)->file_exists(old_name)) {
+			(*it)->fs_rename(old_name, new_name);
 			return;
 		}
 }
@@ -288,12 +289,12 @@
 // or the first directory on the stack we can find.
 // This heuristic is justified by the fact that ths is
 // where we will create new files.
-unsigned long long LayeredFileSystem::DiskSpace() {
+unsigned long long LayeredFileSystem::disk_space() {
 	if (m_home) {
-		return m_home->DiskSpace();
+		return m_home->disk_space();
 	}
 	for (auto it = m_filesystems.rbegin(); it != m_filesystems.rend(); ++it)
 		if (*it)
-			return (*it)->DiskSpace();
+			return (*it)->disk_space();
 	return 0;
 }

=== modified file 'src/io/filesystem/layered_filesystem.h'
--- src/io/filesystem/layered_filesystem.h	2014-07-26 10:43:23 +0000
+++ src/io/filesystem/layered_filesystem.h	2014-09-29 14:39:47 +0000
@@ -50,37 +50,37 @@
 
 	// Add a new filesystem to the top of the stack. Take ownership of the given
 	// filesystem.
-	void AddFileSystem(FileSystem*);
+	void add_file_system(FileSystem*);
 
 	// Set the home filesystem (which is the preferred filesystem for writing
 	// files). Take ownership of the given filesystem.
-	void SetHomeFileSystem(FileSystem*);
-
-	virtual void RemoveFileSystem(const FileSystem &);
-
-	std::set<std::string> ListDirectory(const std::string& path) override;
-
-	bool IsWritable() const override;
-	bool            FileExists(const std::string & path) override;
-	bool     IsDirectory      (const std::string & path) override;
-	void EnsureDirectoryExists(const std::string & dirname) override;
-	void   MakeDirectory      (const std::string & dirname) override;
-
-	void * Load(const std::string & fname, size_t & length) override;
-	virtual void Write
+	void set_home_file_system(FileSystem*);
+
+	virtual void remove_file_system(const FileSystem &);
+
+	std::set<std::string> list_directory(const std::string& path) override;
+
+	bool is_writable            () const override;
+	bool file_exists            (const std::string & path) override;
+	bool is_directory           (const std::string & path) override;
+	void ensure_directory_exists(const std::string & fs_dirname) override;
+	void make_directory         (const std::string & fs_dirname) override;
+
+	void * load(const std::string & fname, size_t & length) override;
+	virtual void write
 		(const std::string & fname, void const * data, int32_t length) override;
 
-	StreamRead  * OpenStreamRead (const std::string & fname) override;
-	StreamWrite * OpenStreamWrite(const std::string & fname) override;
-
-	FileSystem * MakeSubFileSystem(const std::string & dirname) override;
-	FileSystem * CreateSubFileSystem(const std::string & dirname, Type) override;
-	void Unlink(const std::string & file) override;
-	void Rename(const std::string &, const std::string &) override;
-
-	std::string getBasename() override {return std::string();}
-
-	unsigned long long DiskSpace() override;
+	StreamRead  * open_stream_read (const std::string & fname) override;
+	StreamWrite * open_stream_write(const std::string & fname) override;
+
+	FileSystem * make_sub_file_system(const std::string & fs_dirname) override;
+	FileSystem * create_sub_file_system(const std::string & fs_dirname, Type) override;
+	void fs_unlink(const std::string & file) override;
+	void fs_rename(const std::string &, const std::string &) override;
+
+	std::string get_basename() override {return std::string();}
+
+	unsigned long long disk_space() override;
 
 private:
 	std::vector<std::unique_ptr<FileSystem>> m_filesystems;

=== modified file 'src/io/filesystem/test/test_filesystem.cc'
--- src/io/filesystem/test/test_filesystem.cc	2014-07-14 10:45:44 +0000
+++ src/io/filesystem/test/test_filesystem.cc	2014-09-29 14:39:47 +0000
@@ -34,7 +34,7 @@
 	if (!s.empty() && s[0] == '\\')
 	{
 		// Insert drive letter part from current working directory
-		std::string cwd = RealFSImpl("").getWorkingDirectory();
+		std::string cwd = RealFSImpl("").get_working_directory();
 		s.insert(0, cwd.substr(0, 2));
 	}
 	return s;
@@ -53,15 +53,15 @@
 BOOST_AUTO_TEST_SUITE(FileSystemTests)
 #ifndef _WIN32
 #define TEST_CANONICALIZE_NAME(root, path, expected)                          \
-   BOOST_CHECK_EQUAL(RealFSImpl(root).FS_CanonicalizeName(path), expected);
+	BOOST_CHECK_EQUAL(RealFSImpl(root).canonicalize_name(path), expected);
 #else
 #define TEST_CANONICALIZE_NAME(root, path, expected)                          \
-   BOOST_CHECK_EQUAL(RealFSImpl(Win32Path(root)).FS_CanonicalizeName(path), Win32Path(expected));
+	BOOST_CHECK_EQUAL(RealFSImpl(Win32Path(root)).canonicalize_name(path), Win32Path(expected));
 #endif
 
 BOOST_AUTO_TEST_CASE(test_canonicalize_name) {
 	setenv("HOME", "/home/test", 1);
-	std::string cwd = RealFSImpl("").getWorkingDirectory();
+	std::string cwd = RealFSImpl("").get_working_directory();
 
 	// RealFSImpl is constructed with a root directory...
 
@@ -128,8 +128,8 @@
 
 #ifdef _WIN32
 	// Check drive letter handling.
-	BOOST_CHECK_EQUAL(RealFSImpl("C:\\").FS_CanonicalizeName("C:\\"), "C:");
-	BOOST_CHECK_EQUAL(RealFSImpl("C:\\").FS_CanonicalizeName("D:\\"), "C:\\D:");
+	BOOST_CHECK_EQUAL(RealFSImpl("C:\\").canonicalize_name("C:\\"), "C:");
+	BOOST_CHECK_EQUAL(RealFSImpl("C:\\").canonicalize_name("D:\\"), "C:\\D:");
 #endif
 }
 
@@ -138,7 +138,7 @@
 // ~ gets expanded to $HOME
 BOOST_AUTO_TEST_CASE(test_canonicalize_name_home_expansion) {
 	setenv("HOME", "/my/home", 1);
-	std::string cwd = RealFSImpl("").getWorkingDirectory();
+	std::string cwd = RealFSImpl("").get_working_directory();
 
 	TEST_CANONICALIZE_NAME("~", "path", "/my/home/path");
 	TEST_CANONICALIZE_NAME("~/test", "path", "/my/home/test/path");

=== modified file 'src/io/filesystem/zip_exceptions.h'
--- src/io/filesystem/zip_exceptions.h	2014-09-10 13:03:40 +0000
+++ src/io/filesystem/zip_exceptions.h	2014-09-29 14:39:47 +0000
@@ -27,7 +27,7 @@
  *
  * Problems with the zipfile itself or normal file operations should throw
  * FileError or one of it's descendants with an appropriate message. E.g.:
- * throw FileNotFoundError("ZipFilesystem::Load", fname,
+ * throw FileNotFoundError("ZipFilesystem::load", fname,
  * "couldn't open file (from zipfile "+m_zipfilename+")");
  */
 struct ZipOperationError : public std::logic_error {

=== modified file 'src/io/filesystem/zip_filesystem.cc'
--- src/io/filesystem/zip_filesystem.cc	2014-09-10 13:03:40 +0000
+++ src/io/filesystem/zip_filesystem.cc	2014-09-29 14:39:47 +0000
@@ -43,7 +43,7 @@
 m_unzipfile  (nullptr),
 m_oldzip     (false),
 m_zipfilename(zipfile),
-m_basenamezip(FS_Filename(zipfile.c_str())),
+m_basenamezip(fs_filename(zipfile.c_str())),
 m_basename   ()
 {
 	// TODO(unknown): check OS permissions on whether the file is writable
@@ -54,13 +54,13 @@
  */
 ZipFilesystem::~ZipFilesystem()
 {
-	m_Close();
+	m_close();
 }
 
 /**
  * Return true if this directory is writable.
  */
-bool ZipFilesystem::IsWritable() const {
+bool ZipFilesystem::is_writable() const {
 	return true; // should be checked in constructor
 }
 
@@ -69,8 +69,8 @@
  * pathname) in the results. There doesn't seem to be an even remotely
  * cross-platform way of doing this
  */
-std::set<std::string> ZipFilesystem::ListDirectory(const std::string& path_in) {
-	m_OpenUnzip();
+std::set<std::string> ZipFilesystem::list_directory(const std::string& path_in) {
+	m_open_unzip();
 
 	assert(path_in.size()); //  prevent invalid read below
 
@@ -95,7 +95,7 @@
 			 nullptr, 0, nullptr, 0);
 
 		std::string complete_filename = strip_basename(filename_inzip);
-		std::string filename = FS_Filename(complete_filename.c_str());
+		std::string filename = fs_filename(complete_filename.c_str());
 		std::string filepath =
 			complete_filename.substr
 				(0, complete_filename.size() - filename.size());
@@ -118,9 +118,9 @@
  * Returns true if the given file exists, and false if it doesn't.
  * Also returns false if the pathname is invalid
  */
-bool ZipFilesystem::FileExists(const std::string & path) {
+bool ZipFilesystem::file_exists(const std::string & path) {
 	try {
-		m_OpenUnzip(); //  TODO(unknown): check return value
+		m_open_unzip(); //  TODO(unknown): check return value
 	} catch (...) {
 		return false;
 	}
@@ -159,9 +159,9 @@
  * Returns true if the given file is a directory, and false if it doesn't.
  * Also returns false if the pathname is invalid
  */
-bool ZipFilesystem::IsDirectory(const std::string & path) {
+bool ZipFilesystem::is_directory(const std::string & path) {
 
-	if (!FileExists(path))
+	if (!file_exists(path))
 		return false;
 
 	unz_file_info file_info;
@@ -177,13 +177,13 @@
 /**
  * Create a sub filesystem out of this filesystem
  */
-FileSystem * ZipFilesystem::MakeSubFileSystem(const std::string & path) {
-	m_OpenUnzip();
-
-	assert(FileExists(path));
-	assert(IsDirectory(path));
-
-	m_Close();
+FileSystem * ZipFilesystem::make_sub_file_system(const std::string & path) {
+	m_open_unzip();
+
+	assert(file_exists(path));
+	assert(is_directory(path));
+
+	m_close();
 
 	std::string localpath = path;
 
@@ -201,20 +201,20 @@
  * \throw ZipOperationError
  */
 // TODO(unknown): type should be recognized automatically,
-// see Filesystem::Create
-FileSystem * ZipFilesystem::CreateSubFileSystem(const std::string & path, Type const type)
+// see Filesystem::create
+FileSystem * ZipFilesystem::create_sub_file_system(const std::string & path, Type const type)
 {
-	assert(!FileExists(path));
+	assert(!file_exists(path));
 
 	if (type != FileSystem::DIR)
 		throw ZipOperationError
-			("ZipFilesystem::CreateSubFileSystem",
+			("ZipFilesystem::create_sub_file_system",
 			 path, m_zipfilename,
 			 "can not create ZipFilesystem inside another ZipFilesystem");
 
-	EnsureDirectoryExists(path);
+	ensure_directory_exists(path);
 
-	m_Close();
+	m_close();
 
 	std::string localpath = path;
 
@@ -231,9 +231,9 @@
  * Remove a number of files
  * \throw ZipOperationError
  */
-void ZipFilesystem::Unlink(const std::string & filename) {
+void ZipFilesystem::fs_unlink(const std::string & filename) {
 	throw ZipOperationError
-		("ZipFilesystem::Unlink",
+		("ZipFilesystem::unlink",
 		 filename,
 		 m_zipfilename,
 		 "unlinking is not supported inside zipfiles");
@@ -243,11 +243,11 @@
  * Create this directory if it doesn't exist, throws an error
  * if the dir can't be created or if a file with this name exists
  */
-void ZipFilesystem::EnsureDirectoryExists(const std::string & dirname) {
-	if (FileExists(dirname) && IsDirectory(dirname))
+void ZipFilesystem::ensure_directory_exists(const std::string & dirname) {
+	if (file_exists(dirname) && is_directory(dirname))
 		return;
 
-	MakeDirectory(dirname);
+	make_directory(dirname);
 }
 
 /**
@@ -255,11 +255,11 @@
  * if a file is in the way or if the creation fails.
  *
  * Pleas note, this function does not honor parents,
- * MakeDirectory("onedir/otherdir/onemoredir") will fail
+ * make_directory("onedir/otherdir/onemoredir") will fail
  * if either ondir or otherdir is missing
  */
-void ZipFilesystem::MakeDirectory(const std::string & dirname) {
-	m_OpenZip();
+void ZipFilesystem::make_directory(const std::string & dirname) {
+	m_open_zip();
 
 	zip_fileinfo zi;
 
@@ -296,23 +296,23 @@
 		break;
 	case ZIP_ERRNO:
 		throw FileError
-			("ZipFilesystem::MakeDirectory", complete_filename, strerror(errno));
+			("ZipFilesystem::make_directory", complete_filename, strerror(errno));
 	default:
 		throw FileError
-			("ZipFilesystem::MakeDirectory", complete_filename);
+			("ZipFilesystem::make_directory", complete_filename);
 	}
 
 	zipCloseFileInZip(m_zipfile);
 }
 
 /**
- * Read the given file into alloced memory; called by FileRead::Open.
+ * Read the given file into alloced memory; called by FileRead::open.
  * \throw FileNotFoundError if the file couldn't be opened.
  */
-void * ZipFilesystem::Load(const std::string & fname, size_t & length) {
-	if (!FileExists(fname.c_str()) || IsDirectory(fname.c_str()))
+void * ZipFilesystem::load(const std::string & fname, size_t & length) {
+	if (!file_exists(fname.c_str()) || is_directory(fname.c_str()))
 		throw ZipOperationError
-			("ZipFilesystem::Load",
+			("ZipFilesystem::load",
 			 fname,
 			 m_zipfilename,
 			 "could not open file from zipfile");
@@ -330,7 +330,7 @@
 			char buf[200];
 			snprintf(buf, sizeof(buf), "read error %i", len);
 			throw ZipOperationError
-				("ZipFilesystem::Load",
+				("ZipFilesystem::load",
 				 fname,
 				 m_zipfilename,
 				 buf);
@@ -357,13 +357,13 @@
  * Write the given block of memory to the repository.
  * Throws an exception if it fails.
  */
-void ZipFilesystem::Write
+void ZipFilesystem::write
 	(const std::string & fname, void const * const data, int32_t const length)
 {
 	std::string filename = fname;
 	std::replace(filename.begin(), filename.end(), '\\', '/');
 
-	m_OpenZip();
+	m_open_zip();
 
 	zip_fileinfo zi;
 
@@ -389,7 +389,7 @@
 		break;
 	default:
 		throw ZipOperationError
-			("ZipFilesystem::Write", complete_filename, m_zipfilename);
+			("ZipFilesystem::write", complete_filename, m_zipfilename);
 	}
 
 	switch (zipWriteInFileInZip (m_zipfile, data, length)) {
@@ -397,10 +397,10 @@
 		break;
 	case ZIP_ERRNO:
 		throw FileError
-			("ZipFilesystem::Write", complete_filename, strerror(errno));
+			("ZipFilesystem::write", complete_filename, strerror(errno));
 	default:
 		throw FileError
-			("ZipFilesystem::Write", complete_filename);
+			("ZipFilesystem::write", complete_filename);
 	}
 
 	zipCloseFileInZip(m_zipfile);
@@ -413,12 +413,12 @@
 ZipFilesystem::ZipStreamRead::ZipStreamRead(zipFile file, ZipFilesystem* zipfs)
 : m_unzipfile(file), m_zipfs(zipfs) {}
 ZipFilesystem::ZipStreamRead::~ZipStreamRead() {
-	m_zipfs->m_Close();
+	m_zipfs->m_close();
 }
 
-size_t ZipFilesystem::ZipStreamRead::Data(void* data, size_t bufsize)
+size_t ZipFilesystem::ZipStreamRead::data(void* read_data, size_t bufsize)
 {
-	int copied = unzReadCurrentFile(m_unzipfile, data, bufsize);
+	int copied = unzReadCurrentFile(m_unzipfile, read_data, bufsize);
 	if (copied < 0) {
 		throw new DataError("Failed to read from zip file");
 	}
@@ -427,21 +427,21 @@
 	}
 	return copied;
 }
-bool ZipFilesystem::ZipStreamRead::EndOfFile() const
+bool ZipFilesystem::ZipStreamRead::end_of_file() const
 {
 	return unzReadCurrentFile(m_unzipfile, nullptr, 1) == 0;
 }
 
-StreamRead* ZipFilesystem::OpenStreamRead(const std::string& fname) {
-	if (!FileExists(fname.c_str()) || IsDirectory(fname.c_str()))
+StreamRead* ZipFilesystem::open_stream_read(const std::string& fname) {
+	if (!file_exists(fname.c_str()) || is_directory(fname.c_str()))
 		throw ZipOperationError
-			("ZipFilesystem::Load",
+			("ZipFilesystem::load",
 			 fname,
 			 m_zipfilename,
 			 "could not open file from zipfile");
 
 	int32_t method;
-	m_OpenUnzip();
+	m_open_unzip();
 	int result = unzOpenCurrentFile3(m_unzipfile, &method, nullptr, 1, nullptr);
 	switch (result) {
 		case ZIP_OK:
@@ -461,12 +461,12 @@
 : m_zipfile(file), m_zipfs(zipfs) {}
 ZipFilesystem::ZipStreamWrite::~ZipStreamWrite()
 {
-	m_zipfs->m_Close();
+	m_zipfs->m_close();
 }
 
-void ZipFilesystem::ZipStreamWrite::Data(const void* const data, const size_t size)
+void ZipFilesystem::ZipStreamWrite::data(const void* const write_data, const size_t size)
 {
-	int result = zipWriteInFileInZip(m_zipfile, data, size);
+	int result = zipWriteInFileInZip(m_zipfile, write_data, size);
 	switch (result) {
 		case ZIP_OK:
 			break;
@@ -475,8 +475,8 @@
 	}
 }
 
-StreamWrite * ZipFilesystem::OpenStreamWrite(const std::string & fname) {
-	m_OpenZip();
+StreamWrite * ZipFilesystem::open_stream_write(const std::string & fname) {
+	m_open_zip();
 
 	zip_fileinfo zi;
 
@@ -510,7 +510,7 @@
 /**
  * Private Functions below
  */
-void ZipFilesystem::m_Close() {
+void ZipFilesystem::m_close() {
 	if (m_state == STATE_ZIPPING)
 		zipClose(m_zipfile, nullptr);
 	else if (m_state == STATE_UNZIPPPING)
@@ -522,11 +522,11 @@
 /**
  * Open a zipfile for compressing
  */
-void ZipFilesystem::m_OpenZip() {
+void ZipFilesystem::m_open_zip() {
 	if (m_state == STATE_ZIPPING)
 		return;
 
-	m_Close();
+	m_close();
 
 	m_zipfile = zipOpen(m_zipfilename.c_str(), APPEND_STATUS_ADDINZIP);
 	if (!m_zipfile) {
@@ -541,25 +541,25 @@
  * Open a zipfile for extraction
  * \throw FileTypeError
  */
-void ZipFilesystem::m_OpenUnzip() {
+void ZipFilesystem::m_open_unzip() {
 	if (m_state == STATE_UNZIPPPING)
 		return;
 
-	m_Close();
+	m_close();
 
 	m_unzipfile = unzOpen(m_zipfilename.c_str());
 	if (!m_unzipfile)
 		throw FileTypeError
-			("ZipFilesystem::m_OpenUnzip", m_zipfilename, "not a .zip file");
+			("ZipFilesystem::m_open_unzip", m_zipfilename, "not a .zip file");
 
 	m_state = STATE_UNZIPPPING;
 }
 
-void ZipFilesystem::Rename(const std::string &, const std::string &) {
+void ZipFilesystem::fs_rename(const std::string &, const std::string &) {
 	throw wexception("rename inside zip FS is not implemented yet");
 }
 
-unsigned long long ZipFilesystem::DiskSpace() {
+unsigned long long ZipFilesystem::disk_space() {
 	return 0;
 }
 

=== modified file 'src/io/filesystem/zip_filesystem.h'
--- src/io/filesystem/zip_filesystem.h	2014-07-26 10:43:23 +0000
+++ src/io/filesystem/zip_filesystem.h	2014-09-29 14:39:47 +0000
@@ -35,40 +35,40 @@
 	explicit ZipFilesystem(const std::string &);
 	virtual ~ZipFilesystem();
 
-	bool IsWritable() const override;
-
-	std::set<std::string> ListDirectory(const std::string& path) override;
-
-	bool IsDirectory(const std::string & path) override;
-	bool FileExists (const std::string & path) override;
-
-	void * Load(const std::string & fname, size_t & length) override;
-
-	virtual void Write
+	bool is_writable() const override;
+
+	std::set<std::string> list_directory(const std::string& path) override;
+
+	bool is_directory(const std::string & path) override;
+	bool file_exists (const std::string & path) override;
+
+	void * load(const std::string & fname, size_t & length) override;
+
+	virtual void write
 		(const std::string & fname, void const * data, int32_t length) override;
-	void EnsureDirectoryExists(const std::string & dirname) override;
-	void   MakeDirectory      (const std::string & dirname) override;
-
-	virtual StreamRead  * OpenStreamRead
-		(const std::string & fname) override;
-	virtual StreamWrite * OpenStreamWrite
-		(const std::string & fname) override;
-
-	FileSystem * MakeSubFileSystem(const std::string & dirname) override;
-	FileSystem * CreateSubFileSystem(const std::string & dirname, Type) override;
-	void Unlink(const std::string & filename) override;
-	void Rename(const std::string &, const std::string &) override;
-
-	unsigned long long DiskSpace() override;
-
-	static FileSystem * CreateFromDirectory(const std::string & directory);
-
-	std::string getBasename() override {return m_zipfilename;}
+	void ensure_directory_exists(const std::string & fs_dirname) override;
+	void   make_directory      (const std::string & fs_dirname) override;
+
+	virtual StreamRead  * open_stream_read
+		(const std::string & fname) override;
+	virtual StreamWrite * open_stream_write
+		(const std::string & fname) override;
+
+	FileSystem * make_sub_file_system(const std::string & fs_dirname) override;
+	FileSystem * create_sub_file_system(const std::string & fs_dirname, Type) override;
+	void fs_unlink(const std::string & fs_filename) override;
+	void fs_rename(const std::string &, const std::string &) override;
+
+	unsigned long long disk_space() override;
+
+	static FileSystem * create_from_directory(const std::string & directory);
+
+	std::string get_basename() override {return m_zipfilename;}
 
 protected:
-	void m_OpenUnzip();
-	void m_OpenZip();
-	void m_Close();
+	void m_open_unzip();
+	void m_open_zip();
+	void m_close();
 	std::string strip_basename(std::string);
 
 	enum State {
@@ -90,8 +90,8 @@
 	struct ZipStreamRead : StreamRead {
 		explicit ZipStreamRead(zipFile file, ZipFilesystem* zipfs);
 		virtual ~ZipStreamRead();
-		size_t Data(void* data, size_t bufsize) override;
-		bool EndOfFile() const override;
+		size_t data(void* data, size_t bufsize) override;
+		bool end_of_file() const override;
 	private:
 		zipFile m_unzipfile;
 		ZipFilesystem* m_zipfs;
@@ -99,7 +99,7 @@
 	struct ZipStreamWrite : StreamWrite {
 		explicit ZipStreamWrite(zipFile file, ZipFilesystem* zipfs);
 		virtual ~ZipStreamWrite();
-		void Data(const void* const data, size_t size) override;
+		void data(const void* const data, size_t size) override;
 	private:
 		zipFile m_zipfile;
 		ZipFilesystem* m_zipfs;

=== modified file 'src/io/filewrite.cc'
--- src/io/filewrite.cc	2014-07-20 07:44:22 +0000
+++ src/io/filewrite.cc	2014-09-29 14:39:47 +0000
@@ -26,39 +26,39 @@
 }
 
 FileWrite::~FileWrite() {
-	Clear();
+	clear();
 }
 
-void FileWrite::Clear() {
+void FileWrite::clear() {
 	free(data_);
 	data_ = nullptr;
 	length_ = max_size_ = 0;
 	filepos_ = 0;
 }
 
-void FileWrite::Write(FileSystem& fs, char const* const filename) {
-	fs.Write(filename, data_, length_);
-	Clear();
-}