Merge lp:~widelands-dev/widelands/bug-1395278-graphic into lp:widelands

[GunChleoc]

Refactored member variables in src/graphic.

3 remaining and then we're done...

[TiborB (tiborb95)]

LGTM

review: Approve

=== modified file 'src/graphic/font.cc'
--- src/graphic/font.cc	2016-02-03 22:42:34 +0000
+++ src/graphic/font.cc	2016-03-17 17:18:59 +0000
@@ -57,18 +57,18 @@
 	// Load the TrueType Font
 	std::string filename = "i18n/fonts/";
 	filename += name;
-	m_size = input_size;
+	size_ = input_size;
 
 	//  We must keep this File Read open, otherwise the following calls are
 	//  crashing. do not know why...
-	m_fontfile.open(*g_fs, filename);
+	fontfile_.open(*g_fs, filename);
 
-	SDL_RWops * const ops = SDL_RWFromMem(m_fontfile.data(0), m_fontfile.get_size());
+	SDL_RWops * const ops = SDL_RWFromMem(fontfile_.data(0), fontfile_.get_size());
 	if (!ops)
 		throw wexception("could not load font!: RWops Pointer invalid");
 
-	m_font = TTF_OpenFontIndexRW(ops, 1, input_size, 0);
-	if (!m_font)
+	font_ = TTF_OpenFontIndexRW(ops, 1, input_size, 0);
+	if (!font_)
 		throw wexception("could not load font!: %s", TTF_GetError());
 
 	// Compute the line skip based on some glyphs by sampling some letters,
@@ -76,18 +76,18 @@
 	// It seems more reasonable to use TTF_FontLineSkip(), but the fonts
 	// we use claim to have a very excessive line skip.
 	static uint16_t glyphs[] = {'A', '_', '@', ',', 'q', 'y', '"', 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5};
-	m_computed_typical_miny = 0;
-	m_computed_typical_maxy = 0;
+	computed_typical_miny_ = 0;
+	computed_typical_maxy_ = 0;
 
 	for (unsigned int idx = 0; idx < sizeof(glyphs) / sizeof(glyphs[0]); ++idx) {
 		int miny, maxy;
-		if (TTF_GlyphMetrics(m_font, glyphs[idx], nullptr, nullptr, &miny, &maxy, nullptr) < 0)
+		if (TTF_GlyphMetrics(font_, glyphs[idx], nullptr, nullptr, &miny, &maxy, nullptr) < 0)
 			continue; // error, e.g. glyph not found
 
-		if (miny < m_computed_typical_miny)
-			m_computed_typical_miny = miny;
-		if (maxy > m_computed_typical_maxy)
-			m_computed_typical_maxy = maxy;
+		if (miny < computed_typical_miny_)
+			computed_typical_miny_ = miny;
+		if (maxy > computed_typical_maxy_)
+			computed_typical_maxy_ = maxy;
 	}
 }
 
@@ -96,8 +96,8 @@
  */
 Font::~Font()
 {
-	TTF_CloseFont(m_font);
-	m_font = nullptr;
+	TTF_CloseFont(font_);
+	font_ = nullptr;
 }
 
 /**
@@ -105,7 +105,7 @@
  */
 uint32_t Font::height() const
 {
-	return TTF_FontHeight(m_font);
+	return TTF_FontHeight(font_);
 }
 
 /**
@@ -113,7 +113,7 @@
  */
 uint32_t Font::size() const
 {
-	return m_size;
+	return size_;
 }
 
 /**
@@ -121,7 +121,7 @@
  */
 uint32_t Font::ascent() const
 {
-	return TTF_FontAscent(m_font);
+	return TTF_FontAscent(font_);
 }
 
 /**
@@ -129,7 +129,7 @@
  */
 uint32_t Font::lineskip() const
 {
-	return m_computed_typical_maxy - m_computed_typical_miny;
+	return computed_typical_maxy_ - computed_typical_miny_;
 }
 
 /**

=== modified file 'src/graphic/font.h'
--- src/graphic/font.h	2015-10-23 12:05:36 +0000
+++ src/graphic/font.h	2016-03-17 17:18:59 +0000
@@ -50,23 +50,23 @@
 	uint32_t height() const;
 	uint32_t lineskip() const;
 
-	TTF_Font * get_ttf_font() const {return m_font;}
+	TTF_Font * get_ttf_font() const {return font_;}
 
 private:
 	Font(const std::string & name, int size);
 	~Font();
 
-	FileRead m_fontfile;
-	TTF_Font * m_font;
+	FileRead fontfile_;
+	TTF_Font * font_;
 
 	/**
 	 * Work around weird fonts with very large lineskip, to get something
 	 * that makes more sense as the default skip in Latin scripts.
 	 */
-	int32_t m_computed_typical_miny;
-	int32_t m_computed_typical_maxy;
+	int32_t computed_typical_miny_;
+	int32_t computed_typical_maxy_;
 
-	int m_size;
+	int size_;
 };
 
 } // namespace UI

=== modified file 'src/graphic/gl/utils.h'
--- src/graphic/gl/utils.h	2016-02-01 10:32:12 +0000
+++ src/graphic/gl/utils.h	2016-03-17 17:18:59 +0000
@@ -143,7 +143,7 @@
 // Calls glVertexAttribPointer.
 void vertex_attrib_pointer(int vertex_index, int num_items, int stride, int offset);
 
-// Swap order of rows in m_pixels, to compensate for the upside-down nature of the
+// Swap order of rows in pixels, to compensate for the upside-down nature of the
 // OpenGL coordinate system.
 void swap_rows(int width, int height, int pitch, int bpp, uint8_t* pixels);
 

=== modified file 'src/graphic/rendertarget.cc'
--- src/graphic/rendertarget.cc	2016-03-07 18:55:11 +0000
+++ src/graphic/rendertarget.cc	2016-03-17 17:18:59 +0000
@@ -29,7 +29,7 @@
  */
 RenderTarget::RenderTarget(Surface* surf)
 {
-	m_surface = surf;
+	surface_ = surf;
 	reset();
 }
 
@@ -38,30 +38,30 @@
  */
 void RenderTarget::set_window(const Rect& rc, const Point& ofs)
 {
-	m_rect = rc;
-	m_offset = ofs;
+	rect_ = rc;
+	offset_ = ofs;
 
 	// safeguards clipping against the bitmap itself
 
-	if (m_rect.x < 0) {
-		m_offset.x += m_rect.x;
-		m_rect.w = std::max<int32_t>(m_rect.w + m_rect.x, 0);
-		m_rect.x = 0;
-	}
-
-	if (m_rect.x + m_rect.w > m_surface->width())
-		m_rect.w =
-			std::max<int32_t>(m_surface->width() - m_rect.x, 0);
-
-	if (m_rect.y < 0) {
-		m_offset.y += m_rect.y;
-		m_rect.h = std::max<int32_t>(m_rect.h + m_rect.y, 0);
-		m_rect.y = 0;
-	}
-
-	if (m_rect.y + m_rect.h > m_surface->height())
-		m_rect.h =
-			std::max<int32_t>(m_surface->height() - m_rect.y, 0);
+	if (rect_.x < 0) {
+		offset_.x += rect_.x;
+		rect_.w = std::max<int32_t>(rect_.w + rect_.x, 0);
+		rect_.x = 0;
+	}
+
+	if (rect_.x + rect_.w > surface_->width())
+		rect_.w =
+			std::max<int32_t>(surface_->width() - rect_.x, 0);
+
+	if (rect_.y < 0) {
+		offset_.y += rect_.y;
+		rect_.h = std::max<int32_t>(rect_.h + rect_.y, 0);
+		rect_.y = 0;
+	}
+
+	if (rect_.y + rect_.h > surface_->height())
+		rect_.h =
+			std::max<int32_t>(surface_->height() - rect_.y, 0);
 }
 
 /**
@@ -80,13 +80,13 @@
 
 	if (clip(newrect)) {
 		if (previous)
-			*previous = m_rect;
+			*previous = rect_;
 		if (prevofs)
-			*prevofs = m_offset;
+			*prevofs = offset_;
 
 		// Apply the changes
-		m_offset = rc.origin() - (newrect.origin() - m_rect.origin() - m_offset);
-		m_rect = newrect;
+		offset_ = rc.origin() - (newrect.origin() - rect_.origin() - offset_);
+		rect_ = newrect;
 
 		return true;
 	} else return false;
@@ -97,7 +97,7 @@
  */
 int32_t RenderTarget::width() const
 {
-	return m_surface->width();
+	return surface_->width();
 }
 
 /**
@@ -105,7 +105,7 @@
  */
 int32_t RenderTarget::height() const
 {
-	return m_surface->height();
+	return surface_->height();
 }
 
 /**
@@ -117,9 +117,9 @@
 	std::vector<FloatPoint> adjusted_points;
 	adjusted_points.reserve(points.size());
 	for (const auto& p : points) {
-		adjusted_points.emplace_back(p.x + m_offset.x + m_rect.x, p.y + m_offset.y + m_rect.y);
+		adjusted_points.emplace_back(p.x + offset_.x + rect_.x, p.y + offset_.y + rect_.y);
 	}
-	m_surface->draw_line_strip(adjusted_points, color, line_width);
+	surface_->draw_line_strip(adjusted_points, color, line_width);
 }
 
 /**
@@ -129,7 +129,7 @@
 {
 	Rect r(rect);
 	if (clip(r)) {
-		::draw_rect(r, clr, m_surface);
+		::draw_rect(r, clr, surface_);
 	}
 }
 
@@ -137,14 +137,14 @@
 {
 	Rect r(rect);
 	if (clip(r))
-		m_surface->fill_rect(r, clr);
+		surface_->fill_rect(r, clr);
 }
 
 void RenderTarget::brighten_rect(const Rect& rect, int32_t factor)
 {
 	Rect r(rect);
 	if (clip(r))
-		m_surface->brighten_rect(r, factor);
+		surface_->brighten_rect(r, factor);
 }
 
 /**
@@ -161,7 +161,7 @@
 	Rect destination_rect(destination_point.x, destination_point.y, source_rect.w, source_rect.h);
 
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
-		m_surface->blit(destination_rect, *image, source_rect, 1., blend_mode);
+		surface_->blit(destination_rect, *image, source_rect, 1., blend_mode);
 	}
 }
 
@@ -175,7 +175,7 @@
 	Rect destination_rect(destination_point.x, destination_point.y, source_rect.w, source_rect.h);
 
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
-		m_surface->blit_monochrome(destination_rect, *image, source_rect, blend_mode);
+		surface_->blit_monochrome(destination_rect, *image, source_rect, blend_mode);
 	}
 }
 
@@ -197,7 +197,7 @@
 	Rect destination_rect(dst.x, dst.y, source_rect.w, source_rect.h);
 
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
-		m_surface->blit(destination_rect, *image, source_rect, 1., blend_mode);
+		surface_->blit(destination_rect, *image, source_rect, 1., blend_mode);
 	}
 }
 
@@ -207,7 +207,7 @@
                                   const float opacity,
                                   const BlendMode blend_mode) {
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
-		m_surface->blit(destination_rect, *image, source_rect, opacity, blend_mode);
+		surface_->blit(destination_rect, *image, source_rect, opacity, blend_mode);
 	}
 }
 
@@ -216,7 +216,7 @@
                                        Rect source_rect,
 													const RGBAColor& blend) {
 	if (to_surface_geometry(&destination_rect, &source_rect)) {
-		m_surface->blit_monochrome(destination_rect, *image, source_rect, blend);
+		surface_->blit_monochrome(destination_rect, *image, source_rect, blend);
 	}
 }
 
@@ -234,11 +234,11 @@
 	Rect r(rect);
 	Point ofs(gofs);
 	if (clip(r)) {
-		if (m_offset.x < 0)
-			ofs.x -= m_offset.x;
+		if (offset_.x < 0)
+			ofs.x -= offset_.x;
 
-		if (m_offset.y < 0)
-			ofs.y -= m_offset.y;
+		if (offset_.y < 0)
+			ofs.y -= offset_.y;
 
 		// Make sure the offset is within bounds
 		ofs.x = ofs.x % srcw;
@@ -273,7 +273,7 @@
 					srcrc.w = r.w - tx;
 
 				const Rect dst_rect(r.x + tx, r.y + ty, srcrc.w, srcrc.h);
-				m_surface->blit(dst_rect, *image, srcrc, 1., blend_mode);
+				surface_->blit(dst_rect, *image, srcrc, 1., blend_mode);
 
 				tx += srcrc.w;
 
@@ -332,7 +332,7 @@
 	                      source_rect.h);
 	Rect srcrc(source_rect);
 	if (to_surface_geometry(&destination_rect, &srcrc)) {
-		animation.blit(time, destination_rect.origin(), srcrc, player_color, m_surface);
+		animation.blit(time, destination_rect.origin(), srcrc, player_color, surface_);
 	}
 
 	// Look if there is a sound effect registered for this frame and trigger the
@@ -348,23 +348,23 @@
  */
 void RenderTarget::reset()
 {
-	m_rect.x = m_rect.y = 0;
-	m_rect.w = m_surface->width();
-	m_rect.h = m_surface->height();
+	rect_.x = rect_.y = 0;
+	rect_.w = surface_->width();
+	rect_.h = surface_->height();
 
-	m_offset.x = m_offset.y = 0;
+	offset_.x = offset_.y = 0;
 }
 
 /**
- * Offsets r by m_offset and clips r against m_rect.
+ * Offsets r by offset_ and clips r against rect_.
  *
  * If true is returned, r a valid rectangle that can be used.
  * If false is returned, r may not be used and may be partially modified.
  */
 bool RenderTarget::clip(Rect & r) const
 {
-	r.x += m_offset.x;
-	r.y += m_offset.y;
+	r.x += offset_.x;
+	r.y += offset_.y;
 
 	if (r.x < 0) {
 		if (r.w <= -r.x)
@@ -375,10 +375,10 @@
 		r.x = 0;
 	}
 
-	if (r.x + r.w > m_rect.w) {
-		if (m_rect.w <= r.x)
+	if (r.x + r.w > rect_.w) {
+		if (rect_.w <= r.x)
 			return false;
-		r.w = m_rect.w - r.x;
+		r.w = rect_.w - r.x;
 	}
 
 	if (r.y < 0) {
@@ -388,14 +388,14 @@
 		r.y = 0;
 	}
 
-	if (r.y + r.h > m_rect.h) {
-		if (m_rect.h <= r.y)
+	if (r.y + r.h > rect_.h) {
+		if (rect_.h <= r.y)
 			return false;
-		r.h = m_rect.h - r.y;
+		r.h = rect_.h - r.y;
 	}
 
-	r.x += m_rect.x;
-	r.y += m_rect.y;
+	r.x += rect_.x;
+	r.y += rect_.y;
 
 	return r.w && r.h;
 }
@@ -408,8 +408,8 @@
 {
 	assert(0 <= source_rect->x);
 	assert(0 <= source_rect->y);
-	destination_rect->x += m_offset.x;
-	destination_rect->y += m_offset.y;
+	destination_rect->x += offset_.x;
+	destination_rect->y += offset_.y;
 
 	// We have to clip the target rect against our own drawing area. If we make
 	// changes to any side of our rectangle, we have to change the source rect
@@ -431,11 +431,11 @@
 	}
 
 	// Clipping, from the right.
-	if (destination_rect->x + destination_rect->w > m_rect.w) {
-		if (m_rect.w <= destination_rect->x) {
+	if (destination_rect->x + destination_rect->w > rect_.w) {
+		if (rect_.w <= destination_rect->x) {
 			return false;
 		}
-		const int new_destination_w = m_rect.w - destination_rect->x;
+		const int new_destination_w = rect_.w - destination_rect->x;
 		// Adding 0.5 is a cheap way of turning integer truncation into a rounded value.
 		source_rect->w =
 		   0.5 + static_cast<double>(new_destination_w) / destination_rect->w * source_rect->w;
@@ -457,18 +457,18 @@
 	}
 
 	// Clipping, from the bottom.
-	if (destination_rect->y + destination_rect->h > m_rect.h) {
-		if (m_rect.h <= destination_rect->y) {
+	if (destination_rect->y + destination_rect->h > rect_.h) {
+		if (rect_.h <= destination_rect->y) {
 			return false;
 		}
-		const int new_destination_h = m_rect.h - destination_rect->y;
+		const int new_destination_h = rect_.h - destination_rect->y;
 		// Adding 0.5 is a cheap way of turning integer truncation into a rounded value.
 		source_rect->h =
 		   0.5 + static_cast<double>(new_destination_h) / destination_rect->h * source_rect->h;
 		destination_rect->h = new_destination_h;
 	}
 
-	destination_rect->x += m_rect.x;
-	destination_rect->y += m_rect.y;
+	destination_rect->x += rect_.x;
+	destination_rect->y += rect_.y;
 	return true;
 }

=== modified file 'src/graphic/rendertarget.h'
--- src/graphic/rendertarget.h	2016-02-19 19:10:44 +0000
+++ src/graphic/rendertarget.h	2016-03-17 17:18:59 +0000
@@ -116,9 +116,9 @@
 
 	void reset();
 
-	Surface* get_surface() const {return m_surface;}
-	const Rect& get_rect() const {return m_rect;}
-	const Point& get_offset() const {return m_offset;}
+	Surface* get_surface() const {return surface_;}
+	const Rect& get_rect() const {return rect_;}
+	const Point& get_offset() const {return offset_;}
 
 protected:
 	bool clip(Rect & r) const;
@@ -131,12 +131,12 @@
 	                       const RGBColor* player_color,
 	                       const Rect& source_rect);
 
-	///The target surface
-	Surface* m_surface;
-	///The current clip rectangle
-	Rect m_rect;
-	///Drawing offset
-	Point m_offset;
+	/// The target surface
+	Surface* surface_;
+	/// The current clip rectangle
+	Rect rect_;
+	/// Drawing offset
+	Point offset_;
 };
 
 #endif  // end of include guard: WL_GRAPHIC_RENDERTARGET_H

=== modified file 'src/graphic/screen.cc'
--- src/graphic/screen.cc	2016-02-02 09:02:53 +0000
+++ src/graphic/screen.cc	2016-03-17 17:18:59 +0000
@@ -27,31 +27,31 @@
 #include "graphic/render_queue.h"
 #include "graphic/texture.h"
 
-Screen::Screen(int w, int h) : m_w(w), m_h(h) {
+Screen::Screen(int w, int h) : w_(w), h_(h) {
 }
 
 int Screen::width() const {
-	return m_w;
+	return w_;
 }
 
 int Screen::height() const {
-	return m_h;
+	return h_;
 }
 
 std::unique_ptr<Texture> Screen::to_texture() const {
-	std::unique_ptr<uint8_t[]> pixels(new uint8_t[m_w * m_h * 4]);
-	glReadPixels(0, 0, m_w, m_h, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
+	std::unique_ptr<uint8_t[]> pixels(new uint8_t[w_ * h_ * 4]);
+	glReadPixels(0, 0, w_, h_, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
 
-	Gl::swap_rows(m_w, m_h, m_w * 4, 4, pixels.get());
+	Gl::swap_rows(w_, h_, w_ * 4, 4, pixels.get());
 
 	// Ownership of pixels is not taken here. But the Texture() transfers it to
 	// the GPU, frees the SDL surface and after that we are free to free
 	// 'pixels'.
 	SDL_Surface* surface = SDL_CreateRGBSurfaceFrom(pixels.get(),
-	                                                m_w,
-	                                                m_h,
+	                                                w_,
+	                                                h_,
 	                                                32,
-	                                                m_w * 4,
+	                                                w_ * 4,
 	                                                0x000000ff,
 	                                                0x0000ff00,
 	                                                0x00ff0000,

=== modified file 'src/graphic/screen.h'
--- src/graphic/screen.h	2016-02-02 09:02:53 +0000
+++ src/graphic/screen.h	2016-03-17 17:18:59 +0000
@@ -57,7 +57,7 @@
 	void
 	do_fill_rect(const FloatRect& dst_rect, const RGBAColor& color, BlendMode blend_mode) override;
 
-	const int m_w, m_h;
+	const int w_, h_;
 
 	DISALLOW_COPY_AND_ASSIGN(Screen);
 };

=== modified file 'src/graphic/text/rt_errors.h'
--- src/graphic/text/rt_errors.h	2016-01-31 15:31:00 +0000
+++ src/graphic/text/rt_errors.h	2016-03-17 17:18:59 +0000
@@ -28,12 +28,12 @@
 
 class Exception : public std::exception {
 public:
-	Exception(std::string msg) : std::exception(), m_msg(msg) {
+	Exception(std::string msg) : std::exception(), msg_(msg) {
 	}
-	const char* what() const noexcept override {return m_msg.c_str();}
+	const char* what() const noexcept override {return msg_.c_str();}
 
 private:
-	std::string m_msg;
+	std::string msg_;
 };
 
 #define DEF_ERR(Name) class Name : public Exception { \

=== modified file 'src/graphic/text/rt_parse.cc'
--- src/graphic/text/rt_parse.cc	2016-02-21 12:08:36 +0000
+++ src/graphic/text/rt_parse.cc	2016-03-17 17:18:59 +0000
@@ -34,103 +34,103 @@
 
 namespace RT {
 
-Attr::Attr(const std::string& gname, const std::string& value) : m_name(gname), m_value(value) {
+Attr::Attr(const std::string& gname, const std::string& value) : name_(gname), value_(value) {
 }
 
 const std::string& Attr::name() const {
-	return m_name;
+	return name_;
 }
 
 long Attr::get_int() const {
-	long rv = strtol(m_value.c_str(), nullptr, 10);
+	long rv = strtol(value_.c_str(), nullptr, 10);
 	return rv;
 }
 
 std::string Attr::get_string() const {
-	return m_value;
+	return value_;
 }
 
 bool Attr::get_bool() const {
-	if (m_value == "true" || m_value == "1" || m_value == "yes")
+	if (value_ == "true" || value_ == "1" || value_ == "yes")
 		return true;
 	return false;
 }
 
 RGBColor Attr::get_color() const {
-	if (m_value.size() != 6)
-		throw InvalidColor((boost::format("Could not parse '%s' as a color.") % m_value).str());
+	if (value_.size() != 6)
+		throw InvalidColor((boost::format("Could not parse '%s' as a color.") % value_).str());
 
-	uint32_t clrn = strtol(m_value.c_str(), nullptr, 16);
+	uint32_t clrn = strtol(value_.c_str(), nullptr, 16);
 	return RGBColor((clrn >> 16) & 0xff, (clrn >> 8) & 0xff, clrn & 0xff);
 }
 
 void AttrMap::add_attribute(const std::string& name, Attr* a) {
-	m_attrs[name] = std::unique_ptr<Attr>(a);
+	attrs_[name] = std::unique_ptr<Attr>(a);
 }
 
 const Attr& AttrMap::operator[](const std::string& s) const {
-	const auto i = m_attrs.find(s);
-	if (i == m_attrs.end()) {
+	const auto i = attrs_.find(s);
+	if (i == attrs_.end()) {
 		throw AttributeNotFound(s);
 	}
 	return *(i->second);
 }
 
 bool AttrMap::has(const std::string& s) const {
-	return m_attrs.count(s);
+	return attrs_.count(s);
 }
 
 const std::string& Tag::name() const {
-	return m_name;
+	return name_;
 }
 
 const AttrMap& Tag::attrs() const {
-	return m_am;
+	return attribute_map_;
 }
 
-const Tag::ChildList& Tag::childs() const {
-	return m_childs;
+const Tag::ChildList& Tag::children() const {
+	return children_;
 }
 
 Tag::~Tag() {
-	while (m_childs.size()) {
-		delete m_childs.back();
-		m_childs.pop_back();
+	while (children_.size()) {
+		delete children_.back();
+		children_.pop_back();
 	}
 }
 
-void Tag::m_parse_opening_tag(TextStream & ts, TagConstraints & tcs) {
+void Tag::parse_opening_tag(TextStream & ts, TagConstraints & tcs) {
 	ts.expect("<");
-	m_name = ts.till_any(" \t\n>");
+	name_ = ts.till_any(" \t\n>");
 	ts.skip_ws();
 
 	while (ts.peek(1) != ">") {
-		m_parse_attribute(ts, tcs[m_name].allowed_attrs);
+		parse_attribute(ts, tcs[name_].allowed_attrs);
 		ts.skip_ws();
 	}
 
 	ts.expect(">");
 }
 
-void Tag::m_parse_closing_tag(TextStream & ts) {
+void Tag::parse_closing_tag(TextStream & ts) {
 	ts.expect("</");
-	ts.expect(m_name, false);
+	ts.expect(name_, false);
 	ts.expect(">", false);
 }
 
-void Tag::m_parse_attribute(TextStream & ts, std::unordered_set<std::string> & allowed_attrs) {
+void Tag::parse_attribute(TextStream & ts, std::unordered_set<std::string> & allowed_attrs) {
 	std::string aname = ts.till_any("=");
 	if (!allowed_attrs.count(aname))
 		throw SyntaxErrorImpl(ts.line(), ts.col(), "an allowed attribute", aname, ts.peek(100));
 
 	ts.skip(1);
 
-	m_am.add_attribute(aname, new Attr(aname, ts.parse_string()));
+	attribute_map_.add_attribute(aname, new Attr(aname, ts.parse_string()));
 }
 
-void Tag::m_parse_content(TextStream & ts, TagConstraints & tcs, const TagSet & allowed_tags)
+void Tag::parse_content(TextStream & ts, TagConstraints & tcs, const TagSet & allowed_tags)
 {
-	TagConstraint tc = tcs[m_name];
+	TagConstraint tc = tcs[name_];
 
 	for (;;) {
 		if (!tc.text_allowed)
@@ -142,31 +142,31 @@
 			if (!tc.text_allowed) {
 				throw SyntaxErrorImpl(line, col, "no text, as only tags are allowed here", text, ts.peek(100));
 			}
-			m_childs.push_back(new Child(text));
+			children_.push_back(new Child(text));
 		}
 
-		if (ts.peek(2 + m_name.size()) == ("</" + m_name))
+		if (ts.peek(2 + name_.size()) == ("</" + name_))
 			break;
 
 		Tag * child = new Tag();
 		line = ts.line(); col = ts.col(); size_t cpos = ts.pos();
 		child->parse(ts, tcs, allowed_tags);
-		if (!tc.allowed_childs.count(child->name()))
+		if (!tc.allowed_children.count(child->name()))
 			throw SyntaxErrorImpl(line, col, "an allowed tag", child->name(), ts.peek(100, cpos));
 		if (!allowed_tags.empty() && !allowed_tags.count(child->name()))
 			throw SyntaxErrorImpl(line, col, "an allowed tag", child->name(), ts.peek(100, cpos));
 
-		m_childs.push_back(new Child(child));
+		children_.push_back(new Child(child));
 	}
 }
 
 void Tag::parse(TextStream & ts, TagConstraints & tcs, const TagSet & allowed_tags) {
-	m_parse_opening_tag(ts, tcs);
+	parse_opening_tag(ts, tcs);
 
-	TagConstraint tc = tcs[m_name];
+	TagConstraint tc = tcs[name_];
 	if (tc.has_closing_tag) {
-		m_parse_content(ts, tcs, allowed_tags);
-		m_parse_closing_tag(ts);
+		parse_content(ts, tcs, allowed_tags);
+		parse_closing_tag(ts);
 	}
 }
 
@@ -186,19 +186,19 @@
 		tc.allowed_attrs.insert("keep_spaces"); // Keeps blank spaces intact for text editing
 		tc.allowed_attrs.insert("background");
 
-		tc.allowed_childs.insert("p");
-		tc.allowed_childs.insert("vspace");
-		tc.allowed_childs.insert("font");
-		tc.allowed_childs.insert("sub");
+		tc.allowed_children.insert("p");
+		tc.allowed_children.insert("vspace");
+		tc.allowed_children.insert("font");
+		tc.allowed_children.insert("sub");
 		tc.text_allowed = false;
 		tc.has_closing_tag = true;
-		m_tcs["rt"] = tc;
+		tag_constraints_["rt"] = tc;
 	}
 	{ // br tag
 		TagConstraint tc;
 		tc.text_allowed = false;
 		tc.has_closing_tag = false;
-		m_tcs["br"] = tc;
+		tag_constraints_["br"] = tc;
 	}
 	{ // img tag
 		TagConstraint tc;
@@ -206,14 +206,14 @@
 		tc.allowed_attrs.insert("ref");
 		tc.text_allowed = false;
 		tc.has_closing_tag = false;
-		m_tcs["img"] = tc;
+		tag_constraints_["img"] = tc;
 	}
 	{ // vspace tag
 		TagConstraint tc;
 		tc.allowed_attrs.insert("gap");
 		tc.text_allowed = false;
 		tc.has_closing_tag = false;
-		m_tcs["vspace"] = tc;
+		tag_constraints_["vspace"] = tc;
 	}
 	{ // space tag
 		TagConstraint tc;
@@ -221,7 +221,7 @@
 		tc.allowed_attrs.insert("fill");
 		tc.text_allowed = false;
 		tc.has_closing_tag = false;
-		m_tcs["space"] = tc;
+		tag_constraints_["space"] = tc;
 	}
 	{ // sub tag
 		TagConstraint tc;
@@ -236,14 +236,14 @@
 		tc.allowed_attrs.insert("background");
 		tc.allowed_attrs.insert("width");
 
-		tc.allowed_childs.insert("p");
-		tc.allowed_childs.insert("vspace");
-		tc.allowed_childs.insert("font");
-		tc.allowed_childs.insert("sub");
+		tc.allowed_children.insert("p");
+		tc.allowed_children.insert("vspace");
+		tc.allowed_children.insert("font");
+		tc.allowed_children.insert("sub");
 
 		tc.text_allowed = false;
 		tc.has_closing_tag = true;
-		m_tcs["sub"] = tc;
+		tag_constraints_["sub"] = tc;
 	}
 	{ // p tag
 		TagConstraint tc;
@@ -252,14 +252,14 @@
 		tc.allowed_attrs.insert("valign");
 		tc.allowed_attrs.insert("spacing");
 
-		tc.allowed_childs.insert("font");
-		tc.allowed_childs.insert("space");
-		tc.allowed_childs.insert("br");
-		tc.allowed_childs.insert("img");
-		tc.allowed_childs.insert("sub");
+		tc.allowed_children.insert("font");
+		tc.allowed_children.insert("space");
+		tc.allowed_children.insert("br");
+		tc.allowed_children.insert("img");
+		tc.allowed_children.insert("sub");
 		tc.text_allowed = true;
 		tc.has_closing_tag = true;
-		m_tcs["p"] = tc;
+		tag_constraints_["p"] = tc;
 	}
 	{ // font tag
 		TagConstraint tc;
@@ -272,14 +272,14 @@
 		tc.allowed_attrs.insert("shadow");
 		tc.allowed_attrs.insert("ref");
 
-		tc.allowed_childs.insert("br");
-		tc.allowed_childs.insert("space");
-		tc.allowed_childs.insert("p");
-		tc.allowed_childs.insert("font");
-		tc.allowed_childs.insert("sub");
+		tc.allowed_children.insert("br");
+		tc.allowed_children.insert("space");
+		tc.allowed_children.insert("p");
+		tc.allowed_children.insert("font");
+		tc.allowed_children.insert("sub");
 		tc.text_allowed = true;
 		tc.has_closing_tag = true;
-		m_tcs["font"] = tc;
+		tag_constraints_["font"] = tc;
 	}
 }
 
@@ -289,18 +289,18 @@
 Tag * Parser::parse(std::string text, const TagSet & allowed_tags) {
 	boost::replace_all(text, "\\", "\\\\"); // Prevent crashes with \.
 
-	m_ts.reset(new TextStream(text));
+	text_stream_.reset(new TextStream(text));
 
-	m_ts->skip_ws(); m_ts->rskip_ws();
+	text_stream_->skip_ws(); text_stream_->rskip_ws();
 	Tag * rv = new Tag();
-	rv->parse(*m_ts, m_tcs, allowed_tags);
+	rv->parse(*text_stream_, tag_constraints_, allowed_tags);
 
 	return rv;
 }
 std::string Parser::remaining_text() {
-	if (m_ts == nullptr)
+	if (text_stream_ == nullptr)
 		return "";
-	return m_ts->remaining_text();
+	return text_stream_->remaining_text();
 }
 
 }

=== modified file 'src/graphic/text/rt_parse.h'
--- src/graphic/text/rt_parse.h	2014-09-14 11:31:58 +0000
+++ src/graphic/text/rt_parse.h	2016-03-17 17:18:59 +0000
@@ -49,7 +49,7 @@
 	RGBColor get_color() const;
 
 private:
-	const std::string m_name, m_value;
+	const std::string name_, value_;
 };
 
 // This is basically a map<string, Attr>.
@@ -65,12 +65,12 @@
 	bool has(const std::string& name) const;
 
 private:
-	std::map<std::string, std::unique_ptr<Attr>> m_attrs;
+	std::map<std::string, std::unique_ptr<Attr>> attrs_;
 };
 
 struct TagConstraint {
 	std::unordered_set<std::string> allowed_attrs;
-	std::unordered_set<std::string> allowed_childs;
+	std::unordered_set<std::string> allowed_children;
 	bool text_allowed;
 	bool has_closing_tag;
 };
@@ -85,18 +85,18 @@
 
 	const std::string & name() const;
 	const AttrMap & attrs() const;
-	const ChildList & childs() const;
+	const ChildList & children() const;
 	void parse(TextStream& ts, TagConstraints& tcs, const TagSet&);
 
 private:
-	void m_parse_opening_tag(TextStream & ts, TagConstraints & tcs);
-	void m_parse_closing_tag(TextStream & ts);
-	void m_parse_attribute(TextStream & ts, std::unordered_set<std::string> &);
-	void m_parse_content(TextStream & ts, TagConstraints & tc, const TagSet &);
+	void parse_opening_tag(TextStream & ts, TagConstraints & tcs);
+	void parse_closing_tag(TextStream & ts);
+	void parse_attribute(TextStream & ts, std::unordered_set<std::string> &);
+	void parse_content(TextStream & ts, TagConstraints & tc, const TagSet &);
 
-	std::string m_name;
-	AttrMap m_am;
-	ChildList m_childs;
+	std::string name_;
+	AttrMap attribute_map_;
+	ChildList children_;
 };
 
 struct Child {
@@ -122,8 +122,8 @@
 	std::string remaining_text();
 
 private:
-	TagConstraints m_tcs;
-	std::unique_ptr<TextStream> m_ts;
+	TagConstraints tag_constraints_;
+	std::unique_ptr<TextStream> text_stream_;
 };
 }
 

=== modified file 'src/graphic/text/rt_render.cc'
--- src/graphic/text/rt_render.cc	2016-02-14 14:16:26 +0000
+++ src/graphic/text/rt_render.cc	2016-03-17 17:18:59 +0000
@@ -96,13 +96,13 @@
 	using FontMap = map<FontDescr, IFont*>;
 	using FontMapPair = pair<const FontDescr, std::unique_ptr<IFont>>;
 
-	FontMap m_fontmap;
+	FontMap fontmap_;
 
 	DISALLOW_COPY_AND_ASSIGN(FontCache);
 };
 
 FontCache::~FontCache() {
-	for (FontMap::reference& entry : m_fontmap) {
+	for (FontMap::reference& entry : fontmap_) {
 		delete entry.second;
 	}
 }
@@ -154,8 +154,8 @@
 	uint16_t font_size = ns->font_size + ns->fontset->size_offset();
 
 	FontDescr fd = {ns->font_face, font_size};
-	FontMap::iterator i = m_fontmap.find(fd);
-	if (i != m_fontmap.end())
+	FontMap::iterator i = fontmap_.find(fd);
+	if (i != fontmap_.end())
 		return *i->second;
 
 	std::unique_ptr<IFont> font;
@@ -167,7 +167,7 @@
 	}
 	assert(font != nullptr);
 
-	return *m_fontmap.insert(std::make_pair(fd, font.release())).first->second;
+	return *fontmap_.insert(std::make_pair(fd, font.release())).first->second;
 }
 
 struct Reference {
@@ -177,18 +177,18 @@
 
 class RefMap : public IRefMap {
 public:
-	RefMap(const vector<Reference>& refs) : m_refs(refs) {}
+	RefMap(const vector<Reference>& refs) : refs_(refs) {}
 	string query(int16_t x, int16_t y) override {
 		// Should this linear algorithm proof to be too slow (doubtful), the
 		// RefMap could also be efficiently implemented using an R-Tree
-		for (const Reference& c : m_refs)
+		for (const Reference& c : refs_)
 			if (c.dim.contains(Point(x, y)))
 				return c.ref;
 		return "";
 	}
 
 private:
-	vector<Reference> m_refs;
+	vector<Reference> refs_;
 };
 
 class RenderNode {
@@ -199,7 +199,7 @@
 		FLOAT_LEFT,
 	};
 	RenderNode(NodeStyle& ns)
-		: m_floating(NO_FLOAT), m_halign(ns.halign), m_valign(ns.valign), m_x(0), m_y(0) {}
+		: floating_(NO_FLOAT), halign_(ns.halign), valign_(ns.valign), x_(0), y_(0) {}
 	virtual ~RenderNode() {}
 
 	virtual uint16_t width() = 0;
@@ -209,34 +209,34 @@
 
 	virtual bool is_non_mandatory_space() {return false;}
 	virtual bool is_expanding() {return false;}
-	virtual void set_w(uint16_t) {} // Only, when expanding
+	virtual void set_w(uint16_t) {} // Only, when is_expanding
 
 	virtual const vector<Reference> get_references() {return vector<Reference>();}
 
-	Floating get_floating() {return m_floating;}
-	void set_floating(Floating f) {m_floating = f;}
-	UI::Align halign() {return m_halign;}
-	void set_halign(UI::Align ghalign) {m_halign = ghalign;}
-	UI::Align valign() {return m_valign;}
-	void set_valign(UI::Align gvalign) {m_valign = gvalign;}
-	void set_x(int32_t nx) {m_x = nx;}
-	void set_y(int32_t ny) {m_y = ny;}
-	int32_t x() {return m_x;}
-	int32_t y() {return m_y;}
+	Floating get_floating() {return floating_;}
+	void set_floating(Floating f) {floating_ = f;}
+	UI::Align halign() {return halign_;}
+	void set_halign(UI::Align ghalign) {halign_ = ghalign;}
+	UI::Align valign() {return valign_;}
+	void set_valign(UI::Align gvalign) {valign_ = gvalign;}
+	void set_x(int32_t nx) {x_ = nx;}
+	void set_y(int32_t ny) {y_ = ny;}
+	int32_t x() {return x_;}
+	int32_t y() {return y_;}
 
 private:
-	Floating m_floating;
-	UI::Align m_halign;
-	UI::Align m_valign;
-	int32_t m_x, m_y;
+	Floating floating_;
+	UI::Align halign_;
+	UI::Align valign_;
+	int32_t x_, y_;
 };
 
 class Layout {
 public:
-	Layout(vector<RenderNode*>& all) : m_h(0), m_idx(0), m_all_nodes(all) {}
+	Layout(vector<RenderNode*>& all) : h_(0), idx_(0), all_nodes_(all) {}
 	virtual ~Layout() {}
 
-	uint16_t height() {return m_h;}
+	uint16_t height() {return h_;}
 	uint16_t fit_nodes(vector<RenderNode*>& rv, uint16_t w, Borders p, bool shrink_to_fit);
 
 private:
@@ -253,33 +253,33 @@
 		}
 	};
 
-	uint16_t m_fit_line(uint16_t w, const Borders&, vector<RenderNode*>* rv, bool shrink_to_fit);
+	uint16_t fit_line(uint16_t w, const Borders&, vector<RenderNode*>* rv, bool shrink_to_fit);
 
-	uint16_t m_h;
-	size_t m_idx;
-	vector<RenderNode*>& m_all_nodes;
-	priority_queue<ConstraintChange> m_constraint_changes;
+	uint16_t h_;
+	size_t idx_;
+	vector<RenderNode*>& all_nodes_;
+	priority_queue<ConstraintChange> constraint_changes_;
 };
 
-uint16_t Layout::m_fit_line(uint16_t w, const Borders& p, vector<RenderNode*>* rv, bool shrink_to_fit) {
+uint16_t Layout::fit_line(uint16_t w, const Borders& p, vector<RenderNode*>* rv, bool shrink_to_fit) {
 	assert(rv->empty());
 
 	// Remove leading spaces
-	while (m_idx < m_all_nodes.size()
-		&& m_all_nodes[m_idx]->is_non_mandatory_space()
+	while (idx_ < all_nodes_.size()
+		&& all_nodes_[idx_]->is_non_mandatory_space()
 		&& shrink_to_fit) {
-			delete m_all_nodes[m_idx++];
+			delete all_nodes_[idx_++];
 	}
 
 	uint16_t x = p.left;
-	std::size_t first_m_idx = m_idx;
+	std::size_t first_idx = idx_;
 
 	// Calc fitting nodes
-	while (m_idx < m_all_nodes.size()) {
-		RenderNode* n = m_all_nodes[m_idx];
+	while (idx_ < all_nodes_.size()) {
+		RenderNode* n = all_nodes_[idx_];
 		uint16_t nw = n->width();
 		if (x + nw + p.right > w || n->get_floating() != RenderNode::NO_FLOAT) {
-			if (m_idx == first_m_idx) {
+			if (idx_ == first_idx) {
 				nw = w - p.right - x;
 			} else {
 				break;
@@ -287,7 +287,7 @@
 		}
 		n->set_x(x); x += nw;
 		rv->push_back(n);
-		++m_idx;
+		++idx_;
 	}
 	// Remove trailing spaces
 	while (!rv->empty()
@@ -299,9 +299,9 @@
 	}
 
 	// Remaining space in this line
-	uint16_t rem_space = 0;
+	uint16_t remaining_space = 0;
 	if (w < INFINITE_WIDTH) {
-		rem_space = w - p.right - x;
+		remaining_space = w - p.right - x;
 	}
 
 	// Find expanding nodes
@@ -311,7 +311,7 @@
 			expanding_nodes.push_back(idx);
 
 	if (!expanding_nodes.empty()) { // If there are expanding nodes, we fill the space
-		const uint16_t individual_w = rem_space / expanding_nodes.size();
+		const uint16_t individual_w = remaining_space / expanding_nodes.size();
 		for (const size_t idx : expanding_nodes) {
 			rv->at(idx)->set_w(individual_w);
 			for (size_t nidx = idx + 1; nidx < rv->size(); ++nidx)
@@ -321,10 +321,10 @@
 		// Take last elements style in this line and check horizontal alignment
 		if (!rv->empty() && (*rv->rbegin())->halign() != UI::Align::kLeft) {
 			if ((*rv->rbegin())->halign() == UI::Align::kCenter) {
-				rem_space /= 2;  // Otherwise, we align right
+				remaining_space /= 2;  // Otherwise, we align right
 			}
 			for (RenderNode* node : *rv)  {
-				node->set_x(node->x() + rem_space);
+				node->set_x(node->x() + remaining_space);
 			}
 		}
 	}
@@ -343,20 +343,20 @@
  */
 uint16_t Layout::fit_nodes(vector<RenderNode*>& rv, uint16_t w, Borders p, bool shrink_to_fit) {
 	assert(rv.empty());
-	m_h = p.top;
+	h_ = p.top;
 
 	uint16_t max_line_width = 0;
-	while (m_idx < m_all_nodes.size()) {
+	while (idx_ < all_nodes_.size()) {
 		vector<RenderNode*> nodes_in_line;
-		size_t m_idx_before_iteration = m_idx;
-		uint16_t biggest_hotspot = m_fit_line(w, p, &nodes_in_line, shrink_to_fit);
+		size_t idx_before_iteration_ = idx_;
+		uint16_t biggest_hotspot = fit_line(w, p, &nodes_in_line, shrink_to_fit);
 
 		int line_height = 0;
 		int line_start = INFINITE_WIDTH;
 		// Compute real line height and width, taking into account alignement
 		for (RenderNode* n : nodes_in_line) {
 			line_height = max(line_height, biggest_hotspot - n->hotspot_y() + n->height());
-			n->set_y(m_h + biggest_hotspot - n->hotspot_y());
+			n->set_y(h_ + biggest_hotspot - n->hotspot_y());
 			if (line_start >= INFINITE_WIDTH || n->x() < line_start) {
 				line_start = n->x() - p.left;
 			}
@@ -379,18 +379,18 @@
 		}
 		rv.insert(rv.end(), nodes_in_line.begin(), nodes_in_line.end());
 
-		m_h += line_height;
-		while (! m_constraint_changes.empty() && m_constraint_changes.top().at_y <= m_h) {
-			const ConstraintChange& top = m_constraint_changes.top();
+		h_ += line_height;
+		while (! constraint_changes_.empty() && constraint_changes_.top().at_y <= h_) {
+			const ConstraintChange& top = constraint_changes_.top();
 			w += top.delta_w;
 			p.left += top.delta_offset_x;
-			m_constraint_changes.pop();
+			constraint_changes_.pop();
 		}
 
-		if ((m_idx < m_all_nodes.size()) && m_all_nodes[m_idx]->get_floating()) {
-			RenderNode* n = m_all_nodes[m_idx];
-			n->set_y(m_h);
-			ConstraintChange cc = {m_h + n->height(), 0, 0};
+		if ((idx_ < all_nodes_.size()) && all_nodes_[idx_]->get_floating()) {
+			RenderNode* n = all_nodes_[idx_];
+			n->set_y(h_);
+			ConstraintChange cc = {h_ + n->height(), 0, 0};
 			if (n->get_floating() == RenderNode::FLOAT_LEFT) {
 				n->set_x(p.left);
 				p.left += n->width();
@@ -402,16 +402,16 @@
 				cc.delta_w = n->width();
 				max_line_width = max(max_line_width, w);
 			}
-			m_constraint_changes.push(cc);
+			constraint_changes_.push(cc);
 			rv.push_back(n);
-			++m_idx;
+			++idx_;
 		}
-		if (m_idx == m_idx_before_iteration) {
+		if (idx_ == idx_before_iteration_) {
 			throw WidthTooSmall("Could not fit a single render node in line. Width of an Element is too small!");
 		}
 	}
 
-	m_h += p.bottom;
+	h_ += p.bottom;
 	return max_line_width;
 }
 
@@ -423,13 +423,13 @@
 	TextNode(FontCache& font, NodeStyle&, const string& txt);
 	virtual ~TextNode() {}
 
-	uint16_t width() override {return m_w;}
-	uint16_t height() override {return m_h + m_s.spacing;}
+	uint16_t width() override {return w_;}
+	uint16_t height() override {return h_ + nodestyle_.spacing;}
 	uint16_t hotspot_y() override;
 	const vector<Reference> get_references() override {
 		vector<Reference> rv;
-		if (!m_s.reference.empty()) {
-			Reference r = {Rect(0, 0, m_w, m_h), m_s.reference};
+		if (!nodestyle_.reference.empty()) {
+			Reference r = {Rect(0, 0, w_, h_), nodestyle_.reference};
 			rv.push_back(r);
 		}
 		return rv;
@@ -438,25 +438,25 @@
 	Texture* render(TextureCache* texture_cache) override;
 
 protected:
-	uint16_t m_w, m_h;
-	const string m_txt;
-	NodeStyle m_s;
-	FontCache& m_fontcache;
+	uint16_t w_, h_;
+	const string txt_;
+	NodeStyle nodestyle_;
+	FontCache& fontcache_;
 	SdlTtfFont& font_;
 };
 
 TextNode::TextNode(FontCache& font, NodeStyle& ns, const string& txt)
-	: RenderNode(ns), m_txt(txt), m_s(ns), m_fontcache(font),
-	font_(dynamic_cast<SdlTtfFont&>(m_fontcache.get_font(&m_s)))
+	: RenderNode(ns), txt_(txt), nodestyle_(ns), fontcache_(font),
+	font_(dynamic_cast<SdlTtfFont&>(fontcache_.get_font(&nodestyle_)))
 {
-	font_.dimensions(m_txt, ns.font_style, &m_w, &m_h);
+	font_.dimensions(txt_, ns.font_style, &w_, &h_);
 }
 uint16_t TextNode::hotspot_y() {
-	return font_.ascent(m_s.font_style);
+	return font_.ascent(nodestyle_.font_style);
 }
 
 Texture* TextNode::render(TextureCache* texture_cache) {
-	const Texture& img = font_.render(m_txt, m_s.font_color, m_s.font_style, texture_cache);
+	const Texture& img = font_.render(txt_, nodestyle_.font_color, nodestyle_.font_style, texture_cache);
 	Texture* rv = new Texture(img.width(), img.height());
 	rv->blit(Rect(0, 0, img.width(), img.height()),
 	         img,
@@ -473,23 +473,23 @@
 class FillingTextNode : public TextNode {
 public:
 	FillingTextNode(FontCache& font, NodeStyle& ns, uint16_t w, const string& txt, bool expanding = false) :
-		TextNode(font, ns, txt), m_expanding(expanding) {
-			m_w = w;
+		TextNode(font, ns, txt), is_expanding_(expanding) {
+			w_ = w;
 		}
 	virtual ~FillingTextNode() {}
 	Texture* render(TextureCache*) override;
 
-	bool is_expanding() override {return m_expanding;}
-	void set_w(uint16_t w) override {m_w = w;}
+	bool is_expanding() override {return is_expanding_;}
+	void set_w(uint16_t w) override {w_ = w;}
 
 private:
-	bool m_expanding;
+	bool is_expanding_;
 };
 Texture* FillingTextNode::render(TextureCache* texture_cache) {
-	const Texture& t = font_.render(m_txt, m_s.font_color, m_s.font_style, texture_cache);
-	Texture* rv = new Texture(m_w, m_h);
-	for (uint16_t curx = 0; curx < m_w; curx += t.width()) {
-		Rect srcrect(Point(0, 0), min<int>(t.width(), m_w - curx), m_h);
+	const Texture& t = font_.render(txt_, nodestyle_.font_color, nodestyle_.font_style, texture_cache);
+	Texture* rv = new Texture(w_, h_);
+	for (uint16_t curx = 0; curx < w_; curx += t.width()) {
+		Rect srcrect(Point(0, 0), min<int>(t.width(), w_ - curx), h_);
 		rv->blit(Rect(curx, 0, srcrect.w, srcrect.h), t, srcrect, 1., BlendMode::Copy);
 	}
 	return rv;
@@ -502,12 +502,12 @@
 class WordSpacerNode : public TextNode {
 public:
 	WordSpacerNode(FontCache& font, NodeStyle& ns) : TextNode(font, ns, " ") {}
-	static void show_spaces(bool t) {m_show_spaces = t;}
+	static void show_spaces(bool t) {show_spaces_ = t;}
 
 	Texture* render(TextureCache* texture_cache) override {
-		if (m_show_spaces) {
-			Texture* rv = new Texture(m_w, m_h);
-			rv->fill_rect(Rect(0, 0, m_w, m_h), RGBAColor(0xcc, 0, 0, 0xcc));
+		if (show_spaces_) {
+			Texture* rv = new Texture(w_, h_);
+			rv->fill_rect(Rect(0, 0, w_, h_), RGBAColor(0xcc, 0, 0, 0xcc));
 			return rv;
 		}
 		return TextNode::render(texture_cache);
@@ -515,9 +515,9 @@
 	bool is_non_mandatory_space() override {return true;}
 
 private:
-	static bool m_show_spaces;
+	static bool show_spaces_;
 };
-bool WordSpacerNode::m_show_spaces;
+bool WordSpacerNode::show_spaces_;
 
 /*
  * This is a forced newline that can either be inside the text from the user or
@@ -541,41 +541,41 @@
 class SpaceNode : public RenderNode {
 public:
 	SpaceNode(NodeStyle& ns, uint16_t w, uint16_t h = 0, bool expanding = false) :
-		RenderNode(ns), m_w(w), m_h(h), m_bg(nullptr), m_expanding(expanding) {}
+		RenderNode(ns), w_(w), h_(h), background_image_(nullptr), is_expanding_(expanding) {}
 
-	uint16_t height() override {return m_h;}
-	uint16_t width() override {return m_w;}
-	uint16_t hotspot_y() override {return m_h;}
+	uint16_t height() override {return h_;}
+	uint16_t width() override {return w_;}
+	uint16_t hotspot_y() override {return h_;}
 	Texture* render(TextureCache* /* texture_cache */) override {
-		Texture* rv = new Texture(m_w, m_h);
+		Texture* rv = new Texture(w_, h_);
 
 		// Draw background image (tiling)
-		if (m_bg) {
+		if (background_image_) {
 			Rect dst;
 			Rect srcrect(Point(0, 0), 1, 1);
-			for (uint16_t curx = 0; curx < m_w; curx += m_bg->width()) {
+			for (uint16_t curx = 0; curx < w_; curx += background_image_->width()) {
 				dst.x = curx;
 				dst.y = 0;
-				srcrect.w = dst.w = min<int>(m_bg->width(), m_w - curx);
-				srcrect.h = dst.h = m_h;
-				rv->blit(dst, *m_bg, srcrect, 1., BlendMode::Copy);
+				srcrect.w = dst.w = min<int>(background_image_->width(), w_ - curx);
+				srcrect.h = dst.h = h_;
+				rv->blit(dst, *background_image_, srcrect, 1., BlendMode::Copy);
 			}
 		} else {
-			rv->fill_rect(Rect(0, 0, m_w, m_h), RGBAColor(255, 255, 255, 0));
+			rv->fill_rect(Rect(0, 0, w_, h_), RGBAColor(255, 255, 255, 0));
 		}
 		return rv;
 	}
-	bool is_expanding() override {return m_expanding;}
-	void set_w(uint16_t w) override {m_w = w;}
+	bool is_expanding() override {return is_expanding_;}
+	void set_w(uint16_t w) override {w_ = w;}
 
 	void set_background(const Image* s) {
-		m_bg = s; m_h = s->height();
+		background_image_ = s; h_ = s->height();
 	}
 
 private:
-	uint16_t m_w, m_h;
-	const Image* m_bg;  // not owned
-	bool m_expanding;
+	uint16_t w_, h_;
+	const Image* background_image_;  // not owned
+	bool is_expanding_;
 };
 
 /*
@@ -584,17 +584,17 @@
 class SubTagRenderNode : public RenderNode {
 public:
 	SubTagRenderNode(NodeStyle& ns) : RenderNode(ns),
-		m_bg_clr(0, 0, 0), m_bg_clr_set(false), m_bg_img(nullptr) {
+		background_color_(0, 0, 0), is_background_color_set_(false), background_image_(nullptr) {
 	}
 	virtual ~SubTagRenderNode() {
-		for (RenderNode* n : m_nodes_to_render) {
+		for (RenderNode* n : nodes_to_render_) {
 			delete n;
 		}
-		m_nodes_to_render.clear();
+		nodes_to_render_.clear();
 	}
 
-	uint16_t width() override {return m_w + m_margin.left + m_margin.right;}
-	uint16_t height() override {return m_h + m_margin.top + m_margin.bottom;}
+	uint16_t width() override {return w_ + margin_.left + margin_.right;}
+	uint16_t height() override {return h_ + margin_.top + margin_.bottom;}
 	uint16_t hotspot_y() override {return height();}
 
 	Texture* render(TextureCache* texture_cache) override {
@@ -603,33 +603,33 @@
 
 		// Draw Solid background Color
 		bool set_alpha = true;
-		if (m_bg_clr_set) {
-			rv->fill_rect(Rect(Point(m_margin.left, m_margin.top), m_w, m_h), m_bg_clr);
+		if (is_background_color_set_) {
+			rv->fill_rect(Rect(Point(margin_.left, margin_.top), w_, h_), background_color_);
 			set_alpha = false;
 		}
 
 		// Draw background image (tiling)
-		if (m_bg_img) {
+		if (background_image_) {
 			Rect dst;
 			Rect src(0, 0, 0, 0);
 
-			for (uint16_t cury = m_margin.top; cury < m_h + m_margin.top; cury += m_bg_img->height()) {
-				for (uint16_t curx = m_margin.left; curx < m_w + m_margin.left; curx += m_bg_img->width()) {
+			for (uint16_t cury = margin_.top; cury < h_ + margin_.top; cury += background_image_->height()) {
+				for (uint16_t curx = margin_.left; curx < w_ + margin_.left; curx += background_image_->width()) {
 					dst.x = curx;
 					dst.y = cury;
-					src.w = dst.w = min<int>(m_bg_img->width(), m_w + m_margin.left - curx);
-					src.h = dst.h = min<int>(m_bg_img->height(), m_h + m_margin.top - cury);
-					rv->blit(dst, *m_bg_img, src, 1., BlendMode::Copy);
+					src.w = dst.w = min<int>(background_image_->width(), w_ + margin_.left - curx);
+					src.h = dst.h = min<int>(background_image_->height(), h_ + margin_.top - cury);
+					rv->blit(dst, *background_image_, src, 1., BlendMode::Copy);
 				}
 			}
 			set_alpha = false;
 		}
 
-		for (RenderNode* n : m_nodes_to_render) {
+		for (RenderNode* n : nodes_to_render_) {
 			Texture* node_texture = n->render(texture_cache);
 			if (node_texture) {
-				Rect dst = Rect(n->x() + m_margin.left,
-				                n->y() + m_margin.top,
+				Rect dst = Rect(n->x() + margin_.left,
+									 n->y() + margin_.top,
 				                node_texture->width(),
 				                node_texture->height());
 				Rect src = Rect(0, 0, node_texture->width(), node_texture->height());
@@ -640,54 +640,54 @@
 			delete n;
 		}
 
-		m_nodes_to_render.clear();
+		nodes_to_render_.clear();
 
 		return rv;
 	}
-	const vector<Reference> get_references() override {return m_refs;}
+	const vector<Reference> get_references() override {return refs_;}
 	void set_dimensions(uint16_t inner_w, uint16_t inner_h, Borders margin) {
-		m_w = inner_w; m_h = inner_h; m_margin = margin;
+		w_ = inner_w; h_ = inner_h; margin_ = margin;
 	}
 	void set_background(RGBColor clr) {
-		m_bg_clr = clr;
-		m_bg_clr_set = true;
+		background_color_ = clr;
+		is_background_color_set_ = true;
 	}
-	void set_background(const Image* img) {m_bg_img = img;}
-	void set_nodes_to_render(vector<RenderNode*>& n) {m_nodes_to_render = n;}
+	void set_background(const Image* img) {background_image_ = img;}
+	void set_nodes_to_render(vector<RenderNode*>& n) {nodes_to_render_ = n;}
 	void add_reference(int16_t gx, int16_t gy, uint16_t w, uint16_t h, const string& s) {
 		Reference r = {Rect(gx, gy, w, h), s};
-		m_refs.push_back(r);
+		refs_.push_back(r);
 	}
 
 private:
-	uint16_t m_w, m_h;
-	vector<RenderNode*> m_nodes_to_render;
-	Borders m_margin;
-	RGBColor m_bg_clr;
-	bool m_bg_clr_set;
-	const Image* m_bg_img; // Not owned.
-	vector<Reference> m_refs;
+	uint16_t w_, h_;
+	vector<RenderNode*> nodes_to_render_;
+	Borders margin_;
+	RGBColor background_color_;
+	bool is_background_color_set_;
+	const Image* background_image_; // Not owned.
+	vector<Reference> refs_;
 };
 
 class ImgRenderNode : public RenderNode {
 public:
-	ImgRenderNode(NodeStyle& ns, const Image& image) : RenderNode(ns), m_image(image) {
+	ImgRenderNode(NodeStyle& ns, const Image& image) : RenderNode(ns), image_(image) {
 	}
 
-	uint16_t width() override {return m_image.width();}
-	uint16_t height() override {return m_image.height();}
-	uint16_t hotspot_y() override {return m_image.height();}
+	uint16_t width() override {return image_.width();}
+	uint16_t height() override {return image_.height();}
+	uint16_t hotspot_y() override {return image_.height();}
 	Texture* render(TextureCache* texture_cache) override;
 
 private:
-	const Image& m_image;
+	const Image& image_;
 };
 
 Texture* ImgRenderNode::render(TextureCache* /* texture_cache */) {
-	Texture* rv = new Texture(m_image.width(), m_image.height());
-	rv->blit(Rect(0, 0, m_image.width(), m_image.height()),
-	         m_image,
-	         Rect(0, 0, m_image.width(), m_image.height()),
+	Texture* rv = new Texture(image_.width(), image_.height());
+	rv->blit(Rect(0, 0, image_.width(), image_.height()),
+				image_,
+				Rect(0, 0, image_.width(), image_.height()),
 				1.,
 	         BlendMode::Copy);
 	return rv;
@@ -702,27 +702,27 @@
 class TagHandler {
 public:
 	TagHandler(Tag& tag, FontCache& fc, NodeStyle ns, ImageCache* image_cache,
-				  RendererStyle& renderer_style_, const UI::FontSets& fontsets) :
-		m_tag(tag), font_cache_(fc), m_ns(ns), image_cache_(image_cache),
-		renderer_style(renderer_style_), fontsets_(fontsets) {}
+				  RendererStyle& renderer_style, const UI::FontSets& fontsets) :
+		tag_(tag), font_cache_(fc), nodestyle_(ns), image_cache_(image_cache),
+		renderer_style_(renderer_style), fontsets_(fontsets) {}
 	virtual ~TagHandler() {}
 
 	virtual void enter() {}
-	virtual void emit(vector<RenderNode*>&);
+	virtual void emit_nodes(vector<RenderNode*>&);
 
 private:
-	void m_make_text_nodes(const string& txt, vector<RenderNode*>& nodes, NodeStyle& ns);
+	void make_text_nodes(const string& txt, vector<RenderNode*>& nodes, NodeStyle& ns);
 
 protected:
-	Tag& m_tag;
+	Tag& tag_;
 	FontCache& font_cache_;
-	NodeStyle m_ns;
+	NodeStyle nodestyle_;
 	ImageCache* image_cache_;  // Not owned
-	RendererStyle& renderer_style; // Reference to global renderer style in the renderer
+	RendererStyle& renderer_style_; // Reference to global renderer style in the renderer
 	const UI::FontSets& fontsets_;
 };
 
-void TagHandler::m_make_text_nodes(const string& txt, vector<RenderNode*>& nodes, NodeStyle& ns) {
+void TagHandler::make_text_nodes(const string& txt, vector<RenderNode*>& nodes, NodeStyle& ns) {
 	TextStream ts(txt);
 	std::string word;
 	std::vector<RenderNode*> text_nodes;
@@ -804,15 +804,15 @@
 	}
 }
 
-void TagHandler::emit(vector<RenderNode*>& nodes) {
-	for (Child* c : m_tag.childs()) {
+void TagHandler::emit_nodes(vector<RenderNode*>& nodes) {
+	for (Child* c : tag_.children()) {
 		if (c->tag) {
-			std::unique_ptr<TagHandler> th(create_taghandler(*c->tag, font_cache_, m_ns, image_cache_,
-																			 renderer_style, fontsets_));
+			std::unique_ptr<TagHandler> th(create_taghandler(*c->tag, font_cache_, nodestyle_, image_cache_,
+																			 renderer_style_, fontsets_));
 			th->enter();
-			th->emit(nodes);
+			th->emit_nodes(nodes);
 		} else
-			m_make_text_nodes(c->text, nodes, m_ns);
+			make_text_nodes(c->text, nodes, nodestyle_);
 	}
 }
 
@@ -823,15 +823,15 @@
 		: TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets) {}
 
 	void enter() override {
-		const AttrMap& a = m_tag.attrs();
-		if (a.has("color")) m_ns.font_color = a["color"].get_color();
-		if (a.has("size")) m_ns.font_size = a["size"].get_int();
-		if (a.has("face")) m_ns.font_face = a["face"].get_string();
-		if (a.has("bold")) m_ns.font_style |= a["bold"].get_bool() ? IFont::BOLD : 0;
-		if (a.has("italic")) m_ns.font_style |= a["italic"].get_bool() ? IFont::ITALIC : 0;
-		if (a.has("underline")) m_ns.font_style |= a["underline"].get_bool() ? IFont::UNDERLINE : 0;
-		if (a.has("shadow")) m_ns.font_style |= a["shadow"].get_bool() ? IFont::SHADOW : 0;
-		if (a.has("ref")) m_ns.reference = a["ref"].get_string();
+		const AttrMap& a = tag_.attrs();
+		if (a.has("color")) nodestyle_.font_color = a["color"].get_color();
+		if (a.has("size")) nodestyle_.font_size = a["size"].get_int();
+		if (a.has("face")) nodestyle_.font_face = a["face"].get_string();
+		if (a.has("bold")) nodestyle_.font_style |= a["bold"].get_bool() ? IFont::BOLD : 0;
+		if (a.has("italic")) nodestyle_.font_style |= a["italic"].get_bool() ? IFont::ITALIC : 0;
+		if (a.has("underline")) nodestyle_.font_style |= a["underline"].get_bool() ? IFont::UNDERLINE : 0;
+		if (a.has("shadow")) nodestyle_.font_style |= a["shadow"].get_bool() ? IFont::SHADOW : 0;
+		if (a.has("ref")) nodestyle_.reference = a["ref"].get_string();
 	}
 };
 
@@ -839,140 +839,142 @@
 public:
 	PTagHandler(Tag& tag, FontCache& fc, NodeStyle ns, ImageCache* image_cache,
 					RendererStyle& init_renderer_style, const UI::FontSets& fontsets)
-		: TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets), m_indent(0) {
+		: TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets), indent_(0) {
 	}
 
 	void enter() override {
-		const AttrMap& a = m_tag.attrs();
-		if (a.has("indent")) m_indent = a["indent"].get_int();
+		const AttrMap& a = tag_.attrs();
+		if (a.has("indent")) indent_ = a["indent"].get_int();
 		if (a.has("align")) {
 			const std::string align = a["align"].get_string();
 			if (align == "right") {
-				m_ns.halign = UI::Align::kRight;
+				nodestyle_.halign = UI::Align::kRight;
 			} else if (align == "center" || align == "middle") {
-				m_ns.halign = UI::Align::kCenter;
+				nodestyle_.halign = UI::Align::kCenter;
 			} else {
-				m_ns.halign = UI::Align::kLeft;
+				nodestyle_.halign = UI::Align::kLeft;
 			}
 		}
-		m_ns.halign = mirror_alignment(m_ns.halign);
+		nodestyle_.halign = mirror_alignment(nodestyle_.halign);
 		if (a.has("valign")) {
 			const string align = a["valign"].get_string();
 			if (align == "bottom") {
-				m_ns.valign = UI::Align::kBottom;
+				nodestyle_.valign = UI::Align::kBottom;
 			} else if (align == "center" || align == "middle") {
-				m_ns.valign = UI::Align::kCenter;
+				nodestyle_.valign = UI::Align::kCenter;
 			} else {
-				m_ns.valign = UI::Align::kTop;
+				nodestyle_.valign = UI::Align::kTop;
 			}
 		}
 		if (a.has("spacing"))
-			m_ns.spacing = a["spacing"].get_int();
+			nodestyle_.spacing = a["spacing"].get_int();
 	}
-	void emit(vector<RenderNode*>& nodes) override {
+	void emit_nodes(vector<RenderNode*>& nodes) override {
 		// Put a newline if this is not the first paragraph
 		if (!nodes.empty()) {
-			nodes.push_back(new NewlineNode(m_ns));
-		}
-		if (m_indent) {
-			nodes.push_back(new SpaceNode(m_ns, m_indent));
-		}
-		TagHandler::emit(nodes);
+			nodes.push_back(new NewlineNode(nodestyle_));
+		}
+		if (indent_) {
+			nodes.push_back(new SpaceNode(nodestyle_, indent_));
+		}
+		TagHandler::emit_nodes(nodes);
 	}
 
 private:
-	uint16_t m_indent;
+	uint16_t indent_;
 };
 
 class ImgTagHandler : public TagHandler {
 public:
 	ImgTagHandler(Tag& tag, FontCache& fc, NodeStyle ns, ImageCache* image_cache,
 					  RendererStyle& init_renderer_style, const UI::FontSets& fontsets) :
-		TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets), m_rn(nullptr) {
+		TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets), render_node_(nullptr) {
 	}
 
 	void enter() override {
-		const AttrMap& a = m_tag.attrs();
-		m_rn = new ImgRenderNode(m_ns, *image_cache_->get(a["src"].get_string()));
+		const AttrMap& a = tag_.attrs();
+		render_node_ = new ImgRenderNode(nodestyle_, *image_cache_->get(a["src"].get_string()));
 	}
-	void emit(vector<RenderNode*>& nodes) override {
-		nodes.push_back(m_rn);
+	void emit_nodes(vector<RenderNode*>& nodes) override {
+		nodes.push_back(render_node_);
 	}
 
 private:
-	ImgRenderNode* m_rn;
+	ImgRenderNode* render_node_;
 };
 
 class VspaceTagHandler : public TagHandler {
 public:
 	VspaceTagHandler(Tag& tag, FontCache& fc, NodeStyle ns, ImageCache* image_cache,
 						  RendererStyle& init_renderer_style, const UI::FontSets& fontsets) :
-		TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets), m_space(0) {}
+		TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets), space_(0) {}
 
 	void enter() override {
-		const AttrMap& a = m_tag.attrs();
+		const AttrMap& a = tag_.attrs();
 
-		m_space = a["gap"].get_int();
+		space_ = a["gap"].get_int();
 	}
-	void emit(vector<RenderNode*>& nodes) override {
-		nodes.push_back(new SpaceNode(m_ns, 0, m_space));
-		nodes.push_back(new NewlineNode(m_ns));
+	void emit_nodes(vector<RenderNode*>& nodes) override {
+		nodes.push_back(new SpaceNode(nodestyle_, 0, space_));
+		nodes.push_back(new NewlineNode(nodestyle_));
 	}
 
 private:
-	uint16_t m_space;
+	uint16_t space_;
 };
 
 class HspaceTagHandler : public TagHandler {
 public:
 	HspaceTagHandler(Tag& tag, FontCache& fc, NodeStyle ns, ImageCache* image_cache,
 						  RendererStyle& init_renderer_style, const UI::FontSets& fontsets) :
-		TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets), m_bg(nullptr), m_space(0) {}
+		TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets),
+		background_image_(nullptr),
+		space_(0) {}
 
 	void enter() override {
-		const AttrMap& a = m_tag.attrs();
+		const AttrMap& a = tag_.attrs();
 
 		if (a.has("gap"))
-			m_space = a["gap"].get_int();
+			space_ = a["gap"].get_int();
 		else
-			m_space = INFINITE_WIDTH;
+			space_ = INFINITE_WIDTH;
 
 		if (a.has("fill")) {
-			m_fill_text = a["fill"].get_string();
+			fill_text_ = a["fill"].get_string();
 			try {
-				m_bg = image_cache_->get(m_fill_text);
-				m_fill_text = "";
+				background_image_ = image_cache_->get(fill_text_);
+				fill_text_ = "";
 			}
 			catch (ImageNotFound&) {
 			}
 		}
 	}
 
-	void emit(vector<RenderNode*>& nodes) override {
+	void emit_nodes(vector<RenderNode*>& nodes) override {
 		RenderNode* rn = nullptr;
-		if (!m_fill_text.empty()) {
-			if (m_space < INFINITE_WIDTH)
-				rn = new FillingTextNode(font_cache_, m_ns, m_space, m_fill_text);
+		if (!fill_text_.empty()) {
+			if (space_ < INFINITE_WIDTH)
+				rn = new FillingTextNode(font_cache_, nodestyle_, space_, fill_text_);
 			else
-				rn = new FillingTextNode(font_cache_, m_ns, 0, m_fill_text, true);
+				rn = new FillingTextNode(font_cache_, nodestyle_, 0, fill_text_, true);
 		} else {
 			SpaceNode* sn;
-			if (m_space < INFINITE_WIDTH)
-				sn = new SpaceNode(m_ns, m_space, 0);
+			if (space_ < INFINITE_WIDTH)
+				sn = new SpaceNode(nodestyle_, space_, 0);
 			else
-				sn = new SpaceNode(m_ns, 0, 0, true);
+				sn = new SpaceNode(nodestyle_, 0, 0, true);
 
-			if (m_bg)
-				sn->set_background(m_bg);
+			if (background_image_)
+				sn->set_background(background_image_);
 			rn = sn;
 		}
 		nodes.push_back(rn);
 	}
 
 private:
-	string m_fill_text;
-	const Image* m_bg;
-	uint16_t m_space;
+	string fill_text_;
+	const Image* background_image_;
+	uint16_t space_;
 };
 
 class BrTagHandler : public TagHandler {
@@ -982,8 +984,8 @@
 		TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets) {
 	}
 
-	void emit(vector<RenderNode*>& nodes) override {
-		nodes.push_back(new NewlineNode(m_ns));
+	void emit_nodes(vector<RenderNode*>& nodes) override {
+		nodes.push_back(new NewlineNode(nodestyle_));
 	}
 };
 
@@ -997,8 +999,8 @@
 		:
 			TagHandler(tag, fc, ns, image_cache, init_renderer_style, fontsets),
 			shrink_to_fit_(shrink_to_fit),
-			m_w(max_w),
-			m_rn(new SubTagRenderNode(ns))
+			w_(max_w),
+			render_node_(new SubTagRenderNode(ns))
 	{
 	}
 
@@ -1006,14 +1008,14 @@
 		Borders padding, margin;
 
 		handle_unique_attributes();
-		const AttrMap& a = m_tag.attrs();
+		const AttrMap& a = tag_.attrs();
 		if (a.has("background")) {
 			RGBColor clr;
 			try {
 				clr = a["background"].get_color();
-				m_rn->set_background(clr);
+				render_node_->set_background(clr);
 			} catch (InvalidColor&) {
-				m_rn->set_background(image_cache_->get(a["background"].get_string()));
+				render_node_->set_background(image_cache_->get(a["background"].get_string()));
 			}
 		}
 		if (a.has("padding")) {
@@ -1030,89 +1032,89 @@
 		}
 
 		vector<RenderNode*> subnodes;
-		TagHandler::emit(subnodes);
+		TagHandler::emit_nodes(subnodes);
 
-		if (! m_w) { // Determine the width by the width of the widest subnode
+		if (! w_) { // Determine the width by the width of the widest subnode
 			for (RenderNode* n : subnodes) {
 				if (n->width() >= INFINITE_WIDTH)
 					continue;
-				m_w = max<int>(m_w, n->width() + padding.left + padding.right);
+				w_ = max<int>(w_, n->width() + padding.left + padding.right);
 			}
 		}
 
 		// Layout takes ownership of subnodes
 		Layout layout(subnodes);
 		vector<RenderNode*> nodes_to_render;
-		uint16_t max_line_width = layout.fit_nodes(nodes_to_render, m_w, padding, shrink_to_fit_);
-		uint16_t m_extra_width = 0;
-		if (m_w < INFINITE_WIDTH && m_w > max_line_width) {
-			m_extra_width = m_w - max_line_width;
+		uint16_t max_line_width = layout.fit_nodes(nodes_to_render, w_, padding, shrink_to_fit_);
+		uint16_t extra_width = 0;
+		if (w_ < INFINITE_WIDTH && w_ > max_line_width) {
+			extra_width = w_ - max_line_width;
 		}
 
 		// Collect all tags from children
 		for (RenderNode* rn : nodes_to_render) {
 			for (const Reference& r : rn->get_references()) {
-				m_rn->add_reference(rn->x() + r.dim.x, rn->y() + r.dim.y, r.dim.w, r.dim.h, r.ref);
+				render_node_->add_reference(rn->x() + r.dim.x, rn->y() + r.dim.y, r.dim.w, r.dim.h, r.ref);
 			}
 			if (shrink_to_fit_) {
 				if (rn->halign() == UI::Align::kCenter) {
-					rn->set_x(rn->x() - m_extra_width / 2);
+					rn->set_x(rn->x() - extra_width / 2);
 				} else if (rn->halign() == UI::Align::kRight) {
-					rn->set_x(rn->x() - m_extra_width);
+					rn->set_x(rn->x() - extra_width);
 				}
 			}
 		}
-		if (shrink_to_fit_ || m_w >= INFINITE_WIDTH) {
-			m_w = max_line_width;
+		if (shrink_to_fit_ || w_ >= INFINITE_WIDTH) {
+			w_ = max_line_width;
 		}
 
-		if (renderer_style.remaining_width >= m_w) {
-			renderer_style.remaining_width -= m_w;
+		if (renderer_style_.remaining_width >= w_) {
+			renderer_style_.remaining_width -= w_;
 		} else {
-			renderer_style.remaining_width = renderer_style.overall_width;
+			renderer_style_.remaining_width = renderer_style_.overall_width;
 		}
 
-		m_rn->set_dimensions(m_w, layout.height(), margin);
-		m_rn->set_nodes_to_render(nodes_to_render);
+		render_node_->set_dimensions(w_, layout.height(), margin);
+		render_node_->set_nodes_to_render(nodes_to_render);
 	}
-	void emit(vector<RenderNode*>& nodes) override {
-		nodes.push_back(m_rn);
+	void emit_nodes(vector<RenderNode*>& nodes) override {
+		nodes.push_back(render_node_);
 	}
 
 	// Handle attributes that are in sub, but not in rt.
 	virtual void handle_unique_attributes() {
-		const AttrMap& a = m_tag.attrs();
+		const AttrMap& a = tag_.attrs();
 		if (a.has("width")) {
 			std::string width_string = a["width"].get_string();
 			if (width_string == "*") {
-				m_w = renderer_style.remaining_width;
+				w_ = renderer_style_.remaining_width;
 			} else if (boost::algorithm::ends_with(width_string, "%")) {
 				width_string = width_string.substr(0, width_string.length() - 1);
 				uint8_t new_width_percent = strtol(width_string.c_str(), nullptr, 10);
-				m_w = floor(renderer_style.overall_width * new_width_percent / 100);
-				m_w = std::min(m_w, renderer_style.remaining_width);
+				w_ = floor(renderer_style_.overall_width * new_width_percent / 100);
+				w_ = std::min(w_, renderer_style_.remaining_width);
 			} else {
-				m_w = a["width"].get_int();
+				w_ = a["width"].get_int();
 			}
 			shrink_to_fit_ = false;
 		}
 		if (a.has("float")) {
 			const string s = a["float"].get_string();
-			if (s == "right") m_rn->set_floating(RenderNode::FLOAT_RIGHT);
-			else if (s == "left") m_rn->set_floating(RenderNode::FLOAT_LEFT);
+			if (s == "right") render_node_->set_floating(RenderNode::FLOAT_RIGHT);
+			else if (s == "left") render_node_->set_floating(RenderNode::FLOAT_LEFT);
 		}
 		if (a.has("valign")) {
 			const string align = a["valign"].get_string();
-			if (align == "top") m_rn->set_valign(UI::Align::kTop);
-			else if (align == "bottom") m_rn->set_valign(UI::Align::kBottom);
-			else if (align == "center" || align == "middle") m_rn->set_valign(UI::Align::kCenter);
+			if (align == "top") render_node_->set_valign(UI::Align::kTop);
+			else if (align == "bottom") render_node_->set_valign(UI::Align::kBottom);
+			else if (align == "center" || align == "middle") render_node_->set_valign(UI::Align::kCenter);
 		}
 	}
 protected:
 	bool shrink_to_fit_;
 private:
-	uint16_t m_w;
-	SubTagRenderNode* m_rn;
+	uint16_t w_;
+	SubTagRenderNode* render_node_;
 };
 
 class RTTagHandler : public SubTagHandler {
@@ -1124,7 +1126,7 @@
 
 	// Handle attributes that are in rt, but not in sub.
 	void handle_unique_attributes() override {
-		const AttrMap& a = m_tag.attrs();
+		const AttrMap& a = tag_.attrs();
 		WordSpacerNode::show_spaces(a.has("db_show_spaces") ? a["db_show_spaces"].get_bool() : 0);
 		shrink_to_fit_ = shrink_to_fit_ && (a.has("keep_spaces") ? !a["keep_spaces"].get_bool() : true);
 	}
@@ -1193,7 +1195,7 @@
 	RTTagHandler rtrn(*rt, *font_cache_, default_style, image_cache_, renderer_style_, fontsets_, width);
 	vector<RenderNode*> nodes;
 	rtrn.enter();
-	rtrn.emit(nodes);
+	rtrn.emit_nodes(nodes);
 
 	assert(nodes.size() == 1);
 	assert(nodes[0]);

=== modified file 'src/graphic/text/sdl_ttf_font.cc'
--- src/graphic/text/sdl_ttf_font.cc	2016-03-10 16:20:19 +0000
+++ src/graphic/text/sdl_ttf_font.cc	2016-03-17 17:18:59 +0000
@@ -44,7 +44,7 @@
 }
 
 void SdlTtfFont::dimensions(const std::string& txt, int style, uint16_t * gw, uint16_t * gh) {
-	m_set_style(style);
+	set_style(style);
 
 	int w, h;
 	TTF_SizeUTF8(font_, txt.c_str(), &w, &h);
@@ -64,7 +64,7 @@
 	const Texture* rv = texture_cache->get(hash);
 	if (rv) return *rv;
 
-	m_set_style(style);
+	set_style(style);
 
 	SDL_Surface * text_surface = nullptr;
 
@@ -127,7 +127,7 @@
 	return rv;
 }
 
-void SdlTtfFont::m_set_style(int style) {
+void SdlTtfFont::set_style(int style) {
 	int sdl_style = TTF_STYLE_NORMAL;
 	if (style & UNDERLINE) sdl_style |= TTF_STYLE_UNDERLINE;
 

=== modified file 'src/graphic/text/sdl_ttf_font.h'
--- src/graphic/text/sdl_ttf_font.h	2016-02-14 11:39:28 +0000
+++ src/graphic/text/sdl_ttf_font.h	2016-03-17 17:18:59 +0000
@@ -67,7 +67,7 @@
 	uint16_t ascent(int) const override;
 
 private:
-	void m_set_style(int);
+	void set_style(int);
 
 	TTF_Font * font_;
 	int style_;

=== modified file 'src/graphic/text/textstream.cc'
--- src/graphic/text/textstream.cc	2016-02-21 12:06:39 +0000
+++ src/graphic/text/textstream.cc	2016-03-17 17:18:59 +0000
@@ -35,14 +35,14 @@
 	{}
 };
 
-void TextStream::m_consume(size_t cnt) {
+void TextStream::consume(size_t cnt) {
 	while (cnt) {
-		if (m_t[m_i] == '\n') {
-			++m_lineno;
-			m_col = 0;
+		if (text_[pos_] == '\n') {
+			++line_;
+			col_ = 0;
 		} else
-			++m_col;
-		++m_i;
+			++col_;
+		++pos_;
 		--cnt;
 	}
 }
@@ -54,19 +54,19 @@
  * r* means skip_ws starting from the back of the string
  */
 void TextStream::skip_ws() {
-	while (m_i < m_end && isspace(m_t[m_i]))
-		m_consume(1);
+	while (pos_ < end_ && isspace(text_[pos_]))
+		consume(1);
 }
 void TextStream::rskip_ws() {
-	while (m_i < m_end && isspace(m_t[m_end - 1]))
-		--m_end;
+	while (pos_ < end_ && isspace(text_[end_ - 1]))
+		--end_;
 }
 
 /*
  * Return the next few characters without advancing the stream
  */
 string TextStream::peek(size_t n, size_t at) const {
-	return m_t.substr(at > m_t.size() ? m_i : at, n);
+	return text_.substr(at > text_.size() ? pos_ : at, n);
 }
 
 /*
@@ -78,8 +78,8 @@
 		skip_ws();
 
 	if (peek(n.size()) != n)
-		throw SyntaxErrorImpl(m_lineno, m_col, (format("'%s'") % n).str(), peek(n.size()), peek(100));
-	m_consume(n.size());
+		throw SyntaxErrorImpl(line_, col_, (format("'%s'") % n).str(), peek(n.size()), peek(100));
+	consume(n.size());
 }
 
 /*
@@ -91,12 +91,12 @@
 	// Sticking with a double loop because chars will likely be short
 	string rv;
 
-	size_t j = m_i;
-	size_t started_at = m_i;
+	size_t j = pos_;
+	size_t started_at = pos_;
 	bool found = false;
-	while (j < m_end) {
+	while (j < end_) {
 		for (size_t k = 0; k < chars.size(); ++k) {
-			if (chars[k] == m_t[j]) {
+			if (chars[k] == text_[j]) {
 				found = true;
 				break;
 			}
@@ -105,7 +105,7 @@
 
 		// Get rid of control characters
 		// http://en.cppreference.com/w/cpp/language/escape
-		switch (m_t[j]) {
+		switch (text_[j]) {
 		case '\a':
 		case '\b':
 		case '\f':
@@ -116,12 +116,12 @@
 			break;
 		}
 
-		rv += m_t[j];
+		rv += text_[j];
 		++j;
 	}
 	if (!found)
 		throw EndOfTextImpl(started_at, peek(100, started_at));
-	m_consume(j - started_at);
+	consume(j - started_at);
 
 	// Undo the extra \ that were inserted in Parser::parse to prevent crashes.
 	boost::replace_all(rv, "\\\\", "\\");
@@ -137,8 +137,8 @@
 	try {
 		rv = till_any(chars);
 	} catch (EndOfTextImpl &) {
-		rv = m_t.substr(m_i, m_end - m_i);
-		m_consume(m_end + 1 - m_i);
+		rv = text_.substr(pos_, end_ - pos_);
+		consume(end_ + 1 - pos_);
 	}
 	return rv;
 }
@@ -149,9 +149,9 @@
 string TextStream::parse_string() {
 	string delim = peek(1);
 	if (delim == "'" || delim == "\"") {
-		m_consume(1);
+		consume(1);
 		string rv = till_any(delim);
-		m_consume(1);
+		consume(1);
 		return rv;
 	} else
 		return till_any(" \t>");
@@ -161,7 +161,7 @@
  * Return the text that is yet to be parsed
  */
 string TextStream::remaining_text() {
-	return m_t.substr(m_i, m_end - m_i);
+	return text_.substr(pos_, end_ - pos_);
 }
 
 }

=== modified file 'src/graphic/text/textstream.h'
--- src/graphic/text/textstream.h	2014-07-05 16:41:51 +0000
+++ src/graphic/text/textstream.h	2016-03-17 17:18:59 +0000
@@ -28,11 +28,11 @@
 
 class TextStream {
 public:
-	TextStream(std::string text) : m_t(text), m_lineno(1), m_col(0), m_i(0), m_end(text.size()) {}
+	TextStream(std::string text) : text_(text), line_(1), col_(0), pos_(0), end_(text.size()) {}
 
-	size_t line() const {return m_lineno;}
-	size_t col() const {return m_col;}
-	size_t pos() const {return m_i;}
+	size_t line() const {return line_;}
+	size_t col() const {return col_;}
+	size_t pos() const {return pos_;}
 
 	std::string peek(size_t, size_t = -1) const;
 	void expect(std::string, bool = true);
@@ -41,17 +41,17 @@
 	std::string till_any_or_end(std::string);
 	std::string parse_string();
 
-	void skip(size_t d) {m_i += d;}
+	void skip(size_t d) {pos_ += d;}
 	void skip_ws();
 	void rskip_ws();
 
 	std::string remaining_text();
 
 private:
-	void m_consume(size_t);
-	std::string m_t;
-	uint32_t m_lineno, m_col;
-	size_t m_i, m_end;
+	void consume(size_t);
+	std::string text_;
+	uint32_t line_, col_;
+	size_t pos_, end_;
 };
 
 }

=== modified file 'src/graphic/text_layout.cc'
--- src/graphic/text_layout.cc	2016-03-09 07:15:44 +0000
+++ src/graphic/text_layout.cc	2016-03-17 17:18:59 +0000
@@ -210,8 +210,8 @@
  */
 void TextStyle::calc_bare_height_heuristic(const std::string & text, int32_t & miny, int32_t & maxy) const
 {
-	miny = font->m_computed_typical_miny;
-	maxy = font->m_computed_typical_maxy;
+	miny = font->computed_typical_miny_;
+	maxy = font->computed_typical_maxy_;
 
 	setup();
 	std::string::size_type pos = 0;

=== modified file 'src/graphic/text_parser.cc'
--- src/graphic/text_parser.cc	2016-03-10 15:00:32 +0000
+++ src/graphic/text_parser.cc	2016-03-17 17:18:59 +0000
@@ -33,29 +33,29 @@
 namespace UI {
 
 RichtextBlock::RichtextBlock() :
-	m_image_align(UI::Align::kLeft),
-	m_text_align (UI::Align::kLeft)
+	image_align_(UI::Align::kLeft),
+	text_align_ (UI::Align::kLeft)
 {}
 
 RichtextBlock::RichtextBlock(const RichtextBlock & src) {
-	m_images.clear();
-	m_text_blocks.clear();
-	for (uint32_t i = 0; i < src.m_images.size(); ++i)
-		m_images.push_back(src.m_images[i]);
-	for (uint32_t i = 0; i < src.m_text_blocks.size(); ++i)
-		m_text_blocks.push_back(src.m_text_blocks[i]);
-	m_image_align = src.m_image_align;
-	m_text_align = src.m_text_align;
+	images_.clear();
+	text_blocks_.clear();
+	for (uint32_t i = 0; i < src.images_.size(); ++i)
+		images_.push_back(src.images_[i]);
+	for (uint32_t i = 0; i < src.text_blocks_.size(); ++i)
+		text_blocks_.push_back(src.text_blocks_[i]);
+	image_align_ = src.image_align_;
+	text_align_ = src.text_align_;
 }
 
 TextBlock::TextBlock() {
-	m_font_size = 10;
-	m_font_color = RGBColor(255, 255, 0);
-	m_font_weight = "normal";
-	m_font_style = "normal";
-	m_font_decoration = "none";
-	m_font_face = (UI::g_fh1->fontset())->sans();
-	m_line_spacing = 0;
+	font_size_ = 10;
+	font_color_ = RGBColor(255, 255, 0);
+	font_weight_ = "normal";
+	font_style_ = "normal";
+	font_decoration_ = "none";
+	font_face_ = (UI::g_fh1->fontset())->sans();
+	line_spacing_ = 0;
 }
 
 void TextParser::parse

=== modified file 'src/graphic/text_parser.h'
--- src/graphic/text_parser.h	2014-09-10 14:48:40 +0000
+++ src/graphic/text_parser.h	2016-03-17 17:18:59 +0000
@@ -37,68 +37,68 @@
 	TextBlock();
 	// Copy and assignement operators are autogenerated.
 
-	void set_font_size(int32_t const font_size) {m_font_size = font_size;}
-	int32_t get_font_size() const {return m_font_size;}
+	void set_font_size(int32_t const font_size) {font_size_ = font_size;}
+	int32_t get_font_size() const {return font_size_;}
 
-	void set_font_color(const RGBColor & font_color) {m_font_color = font_color;}
-	RGBColor get_font_color() const {return m_font_color;}
+	void set_font_color(const RGBColor & font_color) {font_color_ = font_color;}
+	RGBColor get_font_color() const {return font_color_;}
 
 	void set_font_weight(const std::string & font_weight) {
-		m_font_weight = font_weight;
+		font_weight_ = font_weight;
 	}
-	const std::string & get_font_weight() const {return m_font_weight;}
+	const std::string & get_font_weight() const {return font_weight_;}
 
 	void set_font_style(const std::string & font_style) {
-		m_font_style = font_style;
+		font_style_ = font_style;
 	}
-	const std::string & get_font_style() const {return m_font_style;}
+	const std::string & get_font_style() const {return font_style_;}
 
 	void set_font_decoration(const std::string & font_decoration) {
-		m_font_decoration = font_decoration;
+		font_decoration_ = font_decoration;
 	}
-	const std::string & get_font_decoration() const {return m_font_decoration;}
+	const std::string & get_font_decoration() const {return font_decoration_;}
 
-	void set_font_face(const std::string & font_face) {m_font_face = font_face;}
-	const std::string & get_font_face() const {return m_font_face;}
+	void set_font_face(const std::string & font_face) {font_face_ = font_face;}
+	const std::string & get_font_face() const {return font_face_;}
 
 	void set_line_spacing(int32_t const line_spacing) {
-		m_line_spacing = line_spacing;
+		line_spacing_ = line_spacing;
 	}
-	int32_t get_line_spacing() const {return m_line_spacing;}
+	int32_t get_line_spacing() const {return line_spacing_;}
 
-	void set_words(const std::vector<std::string> & words) {m_words = words;}
-	const std::vector<std::string> & get_words() const {return m_words;}
+	void set_words(const std::vector<std::string> & words) {words_ = words;}
+	const std::vector<std::string> & get_words() const {return words_;}
 
 	void set_line_breaks
 		(const std::vector<std::vector<std::string>::size_type> & line_breaks)
 	{
-		m_line_breaks = line_breaks;
+		line_breaks_ = line_breaks;
 	}
 	const std::vector<std::vector<std::string>::size_type> & get_line_breaks
 		() const
 	{
-		return m_line_breaks;
+		return line_breaks_;
 	}
 private:
-	int32_t                                          m_font_size;
-	RGBColor                                         m_font_color;
-	std::string                                      m_font_weight;
-	std::string                                      m_font_style;
-	std::string                                      m_font_decoration;
-	std::string                                      m_font_face;
-	int32_t                                          m_line_spacing;
-	std::vector<std::string>                         m_words;
+	int32_t                                          font_size_;
+	RGBColor                                         font_color_;
+	std::string                                      font_weight_;
+	std::string                                      font_style_;
+	std::string                                      font_decoration_;
+	std::string                                      font_face_;
+	int32_t                                          line_spacing_;
+	std::vector<std::string>                         words_;
 
 	/**
-	 * Position of manual line breaks (<br>) with respect to @ref m_words.
+	 * Position of manual line breaks (<br>) with respect to @ref words_.
 	 * Sorted in ascending order.
 	 * An entry j in this vector means that a manual line break occurs
-	 * before the j-th word in @ref m_words. In particular, an entry 0
+	 * before the j-th word in @ref words_. In particular, an entry 0
 	 * means that a manual line break occurs before the first word.
 	 * Entries can appear with multiplicity, indicating that multiple
 	 * manual line breaks exist without any words in-between.
 	 */
-	std::vector<std::vector<std::string>::size_type> m_line_breaks;
+	std::vector<std::vector<std::string>::size_type> line_breaks_;
 };
 
 struct RichtextBlock {
@@ -106,27 +106,27 @@
 	RichtextBlock(const RichtextBlock & src);
 
 	void set_images(const std::vector<std::string> & images) {
-		m_images = images;
+		images_ = images;
 	}
-	const std::vector<std::string> & get_images() const {return m_images;}
-
-	void set_image_align(Align const image_align) {m_image_align = image_align;}
-	Align get_image_align() const {return m_image_align;}
-
-	void set_text_align(Align const text_align) {m_text_align = text_align;}
-	Align get_text_align() const {return m_text_align;}
+	const std::vector<std::string> & get_images() const {return images_;}
+
+	void set_image_align(Align const image_align) {image_align_ = image_align;}
+	Align get_image_align() const {return image_align_;}
+
+	void set_text_align(Align const text_align) {text_align_ = text_align;}
+	Align get_text_align() const {return text_align_;}
 
 	void set_text_blocks(const std::vector<TextBlock> & text_blocks) {
-		m_text_blocks = text_blocks;
+		text_blocks_ = text_blocks;
 	}
 	const std::vector<TextBlock> & get_text_blocks() const {
-		return m_text_blocks;
+		return text_blocks_;
 	}
 private:
-	std::vector<std::string> m_images;
-	std::vector<TextBlock>  m_text_blocks;
-	Align                    m_image_align;
-	Align                    m_text_align;
+	std::vector<std::string> images_;
+	std::vector<TextBlock>  text_blocks_;
+	Align image_align_;
+	Align text_align_;
 };
 
 struct TextParser {

=== modified file 'src/graphic/texture.cc'
--- src/graphic/texture.cc	2016-02-02 09:24:10 +0000
+++ src/graphic/texture.cc	2016-03-17 17:18:59 +0000
@@ -103,7 +103,7 @@
 {
 	init(w, h);
 
-	if (m_blit_data.texture_id == 0) {
+	if (blit_data_.texture_id == 0) {
 		return;
 	}
 
@@ -156,9 +156,9 @@
 		throw wexception("Created a sub Texture with zero height and width parent.");
 	}
 
-	m_owns_texture = false;
+	owns_texture_ = false;
 
-	m_blit_data = BlitData {
+	blit_data_ = BlitData {
 		texture,
 		parent_w, parent_h,
 		subrect,
@@ -167,23 +167,23 @@
 
 Texture::~Texture()
 {
-	if (m_owns_texture) {
-		Gl::State::instance().unbind_texture_if_bound(m_blit_data.texture_id);
-		glDeleteTextures(1, &m_blit_data.texture_id);
+	if (owns_texture_) {
+		Gl::State::instance().unbind_texture_if_bound(blit_data_.texture_id);
+		glDeleteTextures(1, &blit_data_.texture_id);
 	}
 }
 
 int Texture::width() const {
-	return m_blit_data.rect.w;
+	return blit_data_.rect.w;
 }
 
 int Texture::height() const {
-	return m_blit_data.rect.h;
+	return blit_data_.rect.h;
 }
 
 void Texture::init(uint16_t w, uint16_t h)
 {
-	m_blit_data = {
+	blit_data_ = {
 		0, // initialized below
 		w, h,
 		Rect(0, 0, w, h),
@@ -192,9 +192,9 @@
 		return;
 	}
 
-	m_owns_texture = true;
-	glGenTextures(1, &m_blit_data.texture_id);
-	Gl::State::instance().bind(GL_TEXTURE0, m_blit_data.texture_id);
+	owns_texture_ = true;
+	glGenTextures(1, &blit_data_.texture_id);
+	Gl::State::instance().bind(GL_TEXTURE0, blit_data_.texture_id);
 
 	// set texture filter to use linear filtering. This looks nicer for resized
 	// texture. Most textures and images are not resized so the filtering
@@ -204,46 +204,46 @@
 }
 
 void Texture::lock() {
-	if (m_blit_data.texture_id == 0) {
+	if (blit_data_.texture_id == 0) {
 		return;
 	}
 
-	if (m_pixels) {
+	if (pixels_) {
 		throw wexception("Called lock() on locked surface.");
 	}
-	if (!m_owns_texture) {
+	if (!owns_texture_) {
 		throw wexception("A surface that does not own its pixels can not be locked..");
 	}
 
-	m_pixels.reset(new uint8_t[width() * height() * 4]);
+	pixels_.reset(new uint8_t[width() * height() * 4]);
 
-	Gl::State::instance().bind(GL_TEXTURE0, m_blit_data.texture_id);
-	glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_pixels.get());
+	Gl::State::instance().bind(GL_TEXTURE0, blit_data_.texture_id);
+	glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels_.get());
 }
 
 void Texture::unlock(UnlockMode mode) {
 	if (width() <= 0 || height() <= 0) {
 		return;
 	}
-	assert(m_pixels);
+	assert(pixels_);
 
 	if (mode == Unlock_Update) {
-		Gl::State::instance().bind(GL_TEXTURE0, m_blit_data.texture_id);
+		Gl::State::instance().bind(GL_TEXTURE0, blit_data_.texture_id);
 		glTexImage2D(GL_TEXTURE_2D, 0, static_cast<GLint>(GL_RGBA), width(), height(), 0, GL_RGBA,
-		             GL_UNSIGNED_BYTE, m_pixels.get());
+		             GL_UNSIGNED_BYTE, pixels_.get());
 	}
 
-	m_pixels.reset(nullptr);
+	pixels_.reset(nullptr);
 }
 
 RGBAColor Texture::get_pixel(uint16_t x, uint16_t y) {
-	assert(m_pixels);
+	assert(pixels_);
 	assert(x < width());
 	assert(y < height());
 
 	RGBAColor color;
 
-	SDL_GetRGBA(*reinterpret_cast<uint32_t*>(&m_pixels[(height() - y - 1) * 4 * width() + 4 * x]),
+	SDL_GetRGBA(*reinterpret_cast<uint32_t*>(&pixels_[(height() - y - 1) * 4 * width() + 4 * x]),
 	            &rgba_format(),
 	            &color.r,
 	            &color.g,
@@ -253,20 +253,20 @@
 }
 
 void Texture::set_pixel(uint16_t x, uint16_t y, const RGBAColor& color) {
-	assert(m_pixels);
+	assert(pixels_);
 	assert(x < width());
 	assert(y < height());
 
-	uint8_t* data = &m_pixels[(height() - y - 1) * 4 * width() + 4 * x];
+	uint8_t* data = &pixels_[(height() - y - 1) * 4 * width() + 4 * x];
 	uint32_t packed_color = SDL_MapRGBA(&rgba_format(), color.r, color.g, color.b, color.a);
 	*(reinterpret_cast<uint32_t *>(data)) = packed_color;
 }
 
 
 void Texture::setup_gl() {
-	assert(m_blit_data.texture_id != 0);
+	assert(blit_data_.texture_id != 0);
 	Gl::State::instance().bind_framebuffer(
-	   GlFramebuffer::instance().id(), m_blit_data.texture_id);
+	   GlFramebuffer::instance().id(), blit_data_.texture_id);
 	glViewport(0, 0, width(), height());
 }
 
@@ -274,7 +274,7 @@
                      const BlitData& texture,
                      float opacity,
                      BlendMode blend_mode) {
-	if (m_blit_data.texture_id == 0) {
+	if (blit_data_.texture_id == 0) {
 		return;
 	}
 	setup_gl();
@@ -287,7 +287,7 @@
                               const BlitData& mask,
                               const RGBColor& blend) {
 
-	if (m_blit_data.texture_id == 0) {
+	if (blit_data_.texture_id == 0) {
 		return;
 	}
 	setup_gl();
@@ -297,7 +297,7 @@
 void Texture::do_blit_monochrome(const FloatRect& dst_rect,
                                  const BlitData& texture,
                                  const RGBAColor& blend) {
-	if (m_blit_data.texture_id == 0) {
+	if (blit_data_.texture_id == 0) {
 		return;
 	}
 	setup_gl();
@@ -305,7 +305,7 @@
 }
 
 void Texture::do_draw_line_strip(std::vector<DrawLineProgram::PerVertexData> vertices) {
-	if (m_blit_data.texture_id == 0) {
+	if (blit_data_.texture_id == 0) {
 		return;
 	}
 	setup_gl();
@@ -315,7 +315,7 @@
 
 void
 Texture::do_fill_rect(const FloatRect& dst_rect, const RGBAColor& color, BlendMode blend_mode) {
-	if (m_blit_data.texture_id == 0) {
+	if (blit_data_.texture_id == 0) {
 		return;
 	}
 	setup_gl();
@@ -323,5 +323,5 @@
 }
 
 const BlitData& Texture::blit_data() const {
-	return m_blit_data;
+	return blit_data_;
 }

=== modified file 'src/graphic/texture.h'
--- src/graphic/texture.h	2016-02-02 09:02:53 +0000
+++ src/graphic/texture.h	2016-03-17 17:18:59 +0000
@@ -99,11 +99,11 @@
 	do_fill_rect(const FloatRect& dst_rect, const RGBAColor& color, BlendMode blend_mode) override;
 
 	// True if we own the texture, i.e. if we need to delete it.
-	bool m_owns_texture;
+	bool owns_texture_;
 
-	BlitData m_blit_data;
+	BlitData blit_data_;
 	/// Pixel data, while the texture is locked
-	std::unique_ptr<uint8_t[]> m_pixels;
+	std::unique_ptr<uint8_t[]> pixels_;
 
 	DISALLOW_COPY_AND_ASSIGN(Texture);
 };

=== modified file 'src/graphic/wordwrap.cc'
--- src/graphic/wordwrap.cc	2016-02-03 22:42:34 +0000
+++ src/graphic/wordwrap.cc	2016-03-17 17:18:59 +0000
@@ -40,20 +40,20 @@
  * and a default-constructed text style.
  */
 WordWrap::WordWrap() :
-	m_wrapwidth(std::numeric_limits<uint32_t>::max()), m_draw_caret(false)
+	wrapwidth_(std::numeric_limits<uint32_t>::max()), draw_caret_(false)
 {
 }
 
 WordWrap::WordWrap(const TextStyle & style, uint32_t gwrapwidth) :
-	m_style(style), m_draw_caret(false)
+	style_(style), draw_caret_(false)
 {
-	m_wrapwidth = gwrapwidth;
+	wrapwidth_ = gwrapwidth;
 
-	if (m_wrapwidth < std::numeric_limits<uint32_t>::max()) {
-		if (m_wrapwidth < 2 * LINE_MARGIN)
-			m_wrapwidth = 0;
+	if (wrapwidth_ < std::numeric_limits<uint32_t>::max()) {
+		if (wrapwidth_ < 2 * LINE_MARGIN)
+			wrapwidth_ = 0;
 		else
-			m_wrapwidth -= 2 * LINE_MARGIN;
+			wrapwidth_ -= 2 * LINE_MARGIN;
 	}
 }
 
@@ -62,7 +62,7 @@
  */
 void WordWrap::set_style(const TextStyle & style)
 {
-	m_style = style;
+	style_ = style;
 }
 
 /**
@@ -70,7 +70,7 @@
  */
 void WordWrap::set_wrapwidth(uint32_t gwrapwidth)
 {
-	m_wrapwidth = gwrapwidth;
+	wrapwidth_ = gwrapwidth;
 }
 
 /**
@@ -79,7 +79,7 @@
  */
 uint32_t WordWrap::wrapwidth() const
 {
-	return m_wrapwidth;
+	return wrapwidth_;
 }
 
 /**
@@ -88,10 +88,10 @@
  */
 void WordWrap::wrap(const std::string & text)
 {
-	m_lines.clear();
+	lines_.clear();
 
 	std::string::size_type line_start = 0;
-	uint32_t margin =  m_style.calc_width_for_wrapping(0x2003); // Em space
+	uint32_t margin =  style_.calc_width_for_wrapping(0x2003); // Em space
 
 	while (line_start <= text.size()) {
 		std::string::size_type next_line_start;
@@ -102,7 +102,7 @@
 		LineData ld;
 		ld.start = line_start;
 		ld.text = text.substr(line_start, line_end - line_start);
-		m_lines.push_back(ld);
+		lines_.push_back(ld);
 
 		line_start = next_line_start;
 	}
@@ -121,13 +121,13 @@
 	 uint32_t safety_margin)
 {
 	std::string::size_type minimum_chars = 1; // So we won't get empty lines
-	assert(text.empty() || m_wrapwidth > safety_margin);
+	assert(text.empty() || wrapwidth_ > safety_margin);
 
 	std::string::size_type orig_end = text.find('\n', line_start);
 	if (orig_end == std::string::npos)
 		orig_end = text.size();
 
-	if (m_wrapwidth == std::numeric_limits<uint32_t>::max() || orig_end - line_start <= minimum_chars) {
+	if (wrapwidth_ == std::numeric_limits<uint32_t>::max() || orig_end - line_start <= minimum_chars) {
 		// Special fast path when wrapping is disabled or
 		// original text line contains at most minimum_chars characters
 		line_end = orig_end;
@@ -137,8 +137,8 @@
 
 
 	// Optimism: perhaps the entire line fits?
-	if (text_width(text.substr(line_start, orig_end - line_start), m_style.font->size())
-		 <= m_wrapwidth - safety_margin) {
+	if (text_width(text.substr(line_start, orig_end - line_start), style_.font->size())
+		 <= wrapwidth_ - safety_margin) {
 		line_end = orig_end;
 		next_line_start = orig_end + 1;
 		return;
@@ -196,13 +196,13 @@
 	int32_t end = -1;
 	icu::UnicodeString unicode_line;
 
-	while ((line_width < (m_wrapwidth - safety_margin)) && (end < unicode_word.length())) {
+	while ((line_width < (wrapwidth_ - safety_margin)) && (end < unicode_word.length())) {
 		++end;
 		UChar c = unicode_word.charAt(end);
 		// Diacritics do not add to the line width
 		if (!i18n::is_diacritic(c)) {
 			// This only estimates the width
-			line_width += m_style.calc_width_for_wrapping(c);
+			line_width += style_.calc_width_for_wrapping(c);
 		}
 		unicode_line += c;
 	}
@@ -210,7 +210,7 @@
 	// Now make sure that it really fits.
 	std::string::size_type test_cutoff = line_start + end * 2 / 3;
 	while ((end > 0) && (static_cast<uint32_t>(line_start + end) > test_cutoff)) {
-		if (text_width(text.substr(line_start, end), m_style.font->size()) > m_wrapwidth - safety_margin) {
+		if (text_width(text.substr(line_start, end), style_.font->size()) > wrapwidth_ - safety_margin) {
 			--end;
 		} else {
 			break;
@@ -241,9 +241,9 @@
 bool WordWrap::line_fits(const std::string& text, uint32_t safety_margin) const {
 	// calc_width_for_wrapping is fast, but it will underestimate the width.
 	// So, we test again with text_width to make sure that the line really fits.
-	return m_style.calc_width_for_wrapping(i18n::make_ligatures(text.c_str()))
-			<= m_wrapwidth - safety_margin &&
-			text_width(text, m_style.font->size()) <= m_wrapwidth - safety_margin;
+	return style_.calc_width_for_wrapping(i18n::make_ligatures(text.c_str()))
+			<= wrapwidth_ - safety_margin &&
+			text_width(text, style_.font->size()) <= wrapwidth_ - safety_margin;
 }
 
 
@@ -256,8 +256,8 @@
 {
 	uint32_t calculated_width = 0;
 
-	for (uint32_t line = 0; line < m_lines.size(); ++line) {
-		uint32_t linewidth = text_width(m_lines[line].text, m_style.font->size());
+	for (uint32_t line = 0; line < lines_.size(); ++line) {
+		uint32_t linewidth = text_width(lines_[line].text, style_.font->size());
 		if (linewidth > calculated_width)
 			calculated_width = linewidth;
 	}
@@ -271,11 +271,11 @@
 uint32_t WordWrap::height() const
 {
 	uint16_t fontheight = 0;
-	if (!m_lines.empty()) {
-		fontheight = text_height(m_lines[0].text, m_style.font->size());
+	if (!lines_.empty()) {
+		fontheight = text_height(lines_[0].text, style_.font->size());
 	}
 
-	return fontheight * (m_lines.size()) + 2 * LINE_MARGIN;
+	return fontheight * (lines_.size()) + 2 * LINE_MARGIN;
 }
 
 /**
@@ -284,25 +284,25 @@
  */
 void WordWrap::calc_wrapped_pos(uint32_t caret, uint32_t & line, uint32_t & pos) const
 {
-	assert(m_lines.size());
-	assert(m_lines[0].start == 0);
+	assert(lines_.size());
+	assert(lines_[0].start == 0);
 
 	uint32_t min = 0;
-	uint32_t max = m_lines.size() - 1;
+	uint32_t max = lines_.size() - 1;
 
 	while (max > min) {
 		uint32_t mid = min + (max - min + 1) / 2;
 
-		if (caret >= m_lines[mid].start)
+		if (caret >= lines_[mid].start)
 			min = mid;
 		else
 			max = mid - 1;
 	}
 
-	assert(caret >= m_lines[min].start);
+	assert(caret >= lines_[min].start);
 
 	line = min;
-	pos = caret - m_lines[min].start;
+	pos = caret - lines_[min].start;
 }
 
 /**
@@ -310,7 +310,7 @@
  */
 uint32_t WordWrap::line_offset(uint32_t line) const
 {
-	return m_lines[line].start;
+	return lines_[line].start;
 }
 
 /**
@@ -320,7 +320,7 @@
  */
 void WordWrap::draw(RenderTarget & dst, Point where, Align align, uint32_t caret)
 {
-	if (m_lines.empty()) return;
+	if (lines_.empty()) return;
 
 	uint32_t caretline, caretpos;
 
@@ -339,28 +339,28 @@
 
 	Align alignment = mirror_alignment(align);
 
-	uint16_t fontheight = text_height(m_lines[0].text, m_style.font->size());
-	for (uint32_t line = 0; line < m_lines.size(); ++line, where.y += fontheight) {
+	uint16_t fontheight = text_height(lines_[0].text, style_.font->size());
+	for (uint32_t line = 0; line < lines_.size(); ++line, where.y += fontheight) {
 		if (where.y >= dst.height() || int32_t(where.y + fontheight) <= 0)
 			continue;
 
 		Point point(where.x, where.y);
 
 		if (static_cast<int>(alignment & UI::Align::kRight)) {
-			point.x += m_wrapwidth - LINE_MARGIN;
+			point.x += wrapwidth_ - LINE_MARGIN;
 		}
 
 		const Image* entry_text_im =
-				UI::g_fh1->render(as_editorfont(m_lines[line].text,
-														  m_style.font->size() - UI::g_fh1->fontset()->size_offset(),
-														  m_style.fg));
+				UI::g_fh1->render(as_editorfont(lines_[line].text,
+														  style_.font->size() - UI::g_fh1->fontset()->size_offset(),
+														  style_.fg));
 		UI::correct_for_align(alignment, entry_text_im->width(), fontheight, &point);
 		dst.blit(point, entry_text_im);
 
-		if (m_draw_caret && line == caretline) {
-			std::string line_to_caret = m_lines[line].text.substr(0, caretpos);
+		if (draw_caret_ && line == caretline) {
+			std::string line_to_caret = lines_[line].text.substr(0, caretpos);
 			// TODO(GunChleoc): Arabic: Fix cursor position for BIDI text.
-			int caret_x = text_width(line_to_caret, m_style.font->size());
+			int caret_x = text_width(line_to_caret, style_.font->size());
 
 			const Image* caret_image = g_gr->images().get("images/ui_basic/caret.png");
 			Point caretpt;

=== modified file 'src/graphic/wordwrap.h'
--- src/graphic/wordwrap.h	2016-01-28 21:27:04 +0000
+++ src/graphic/wordwrap.h	2016-03-17 17:18:59 +0000
@@ -45,14 +45,14 @@
 
 	uint32_t width() const;
 	uint32_t height() const;
-	void set_draw_caret(bool draw_it) {m_draw_caret = draw_it;}
+	void set_draw_caret(bool draw_it) {draw_caret_ = draw_it;}
 
 	void draw
 		(RenderTarget & dst, Point where, Align align = UI::Align::kLeft,
 		 uint32_t caret = std::numeric_limits<uint32_t>::max());
 
 	void calc_wrapped_pos(uint32_t caret, uint32_t & line, uint32_t & pos) const;
-	uint32_t nrlines() const {return m_lines.size();}
+	uint32_t nrlines() const {return lines_.size();}
 	uint32_t line_offset(uint32_t line) const;
 
 private:
@@ -73,11 +73,11 @@
 
 	bool line_fits(const std::string& text, uint32_t safety_margin) const;
 
-	TextStyle m_style;
-	uint32_t m_wrapwidth;
-	bool m_draw_caret;
+	TextStyle style_;
+	uint32_t wrapwidth_;
+	bool draw_caret_;
 
-	std::vector<LineData> m_lines;
+	std::vector<LineData> lines_;
 };
 
 } // namespace UI