--- a/libclient/malikania/client/backend/sdl/window_backend.cpp	Wed Sep 27 12:52:36 2017 +0200
+++ b/libclient/malikania/client/backend/sdl/window_backend.cpp	Wed Sep 27 20:06:48 2017 +0200
@@ -341,24 +341,20 @@
     auto kc = keycodes_map.find(ev.key.keysym.sym);
     auto sc = scancodes_map.find(ev.key.keysym.scancode);
 
-    if (kc == keycodes_map.end() || sc == scancodes_map.end()) {
+    if (kc == keycodes_map.end() || sc == scancodes_map.end())
         return;
-    }
 
     key_event kev{kc->second, sc->second, mod::none};
 
     // Modifier is a mask.
-    for (const auto& pair : modifiers_map) {
-        if (ev.key.keysym.mod & pair.first) {
+    for (const auto& pair : modifiers_map)
+        if (ev.key.keysym.mod & pair.first)
             kev.modifiers |= pair.second;
-        }
-    }
 
-    if (ev.type == SDL_KEYDOWN) {
+    if (ev.type == SDL_KEYDOWN)
         self.handle_key_down(kev);
-    } else {
+    else
         self.handle_key_up(kev);
-    }
 }
 
 void window::backend_impl::handle_mouse(window& self, const SDL_Event& ev)
@@ -367,20 +363,18 @@
 
     auto which = button_map.find(ev.button.button);
 
-    if (which == button_map.end()) {
+    if (which == button_map.end())
         return;
-    }
 
     mouse_click_event mev{
         which->second,
         point(ev.button.x, ev.button.y)
     };
 
-    if (ev.type == SDL_MOUSEBUTTONDOWN) {
+    if (ev.type == SDL_MOUSEBUTTONDOWN)
         self.handle_mouse_down(mev);
-    } else {
+    else
         self.handle_mouse_up(mev);
-    }
 }
 
 void window::backend_impl::handle_mouse_wheel(window& self, const SDL_Event& ev)
@@ -400,13 +394,13 @@
 }
 
 window::backend_impl::backend_impl(window&, unsigned width, unsigned height, const std::string& title)
-    : m_window(nullptr, nullptr)
-    , m_renderer(nullptr, nullptr)
+    : window_(nullptr, nullptr)
+    , renderer_(nullptr, nullptr)
 {
     SDL_SetMainReady();
     SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
 
-    m_window = {
+    window_ = {
         SDL_CreateWindow(
             title.c_str(),
             SDL_WINDOWPOS_UNDEFINED,
@@ -417,116 +411,79 @@
         SDL_DestroyWindow
     };
 
-    if (m_window == nullptr) {
+    if (window_ == nullptr)
         throw std::runtime_error(SDL_GetError());
-    }
 
     // Create renderer.
-    m_renderer = {
-        SDL_CreateRenderer(m_window.get(), -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
+    renderer_ = {
+        SDL_CreateRenderer(window_.get(), -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
         SDL_DestroyRenderer
     };
 
-    if (m_renderer == nullptr) {
+    if (renderer_ == nullptr)
         throw std::runtime_error(SDL_GetError());
-    }
-    if (TTF_Init() == -1) {
+    if (TTF_Init() == -1)
         throw std::runtime_error(TTF_GetError());
-    }
 }
 
 void window::backend_impl::clear()
 {
-    SDL_RenderClear(m_renderer.get());
+    SDL_RenderClear(renderer_.get());
 }
 
 void window::backend_impl::present()
 {
-    SDL_RenderPresent(m_renderer.get());
+    SDL_RenderPresent(renderer_.get());
 }
 
-#if 0
-
-// TODO: see later if it's really needed
-
-Size window::backend_impl::resolution()
-{
-    SDL_DisplayMode current;
-    int width = 0;
-    int height = 0;
-    for (int i = 0; i < SDL_GetNumVideoDisplays(); i++) {
-        int error = SDL_GetCurrentDisplayMode(i, &current);
-        if (error == 0) {
-            // Get the last one
-            // TODO test with only one display mode, but we have to test with more than that
-            width = current.w;
-            height = current.hpp;
-        } else {
-            throw std::runtime_error("Could not get display mode for video display" + std::string(SDL_GetError()));
-        }
-    }
-
-    return Size((unsigned)width, (unsigned)height);
-}
-
-#endif
-
 color window::backend_impl::drawing_color() const
 {
     SDL_Color color;
 
-    if (SDL_GetRenderDrawColor(m_renderer.get(), &color.r, &color.g, &color.b, &color.a) < 0) {
+    if (SDL_GetRenderDrawColor(renderer_.get(), &color.r, &color.g, &color.b, &color.a) < 0)
         throw std::runtime_error(SDL_GetError());
-    }
 
     return {color.r, color.g, color.b, color.a};
 }
 
 void window::backend_impl::set_drawing_color(const color& color)
 {
-    if (SDL_SetRenderDrawColor(m_renderer.get(), color.red(), color.green(), color.blue(), color.alpha()) < 0) {
+    if (SDL_SetRenderDrawColor(renderer_.get(), color.red(), color.green(), color.blue(), color.alpha()) < 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::draw_line(const line& line)
 {
-    if (SDL_RenderDrawLine(m_renderer.get(), line.x1(), line.y1(), line.x2(), line.y2()) != 0) {
+    if (SDL_RenderDrawLine(renderer_.get(), line.x1(), line.y1(), line.x2(), line.y2()) != 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::draw_lines(const std::vector<point>& points)
 {
     std::vector<SDL_Point> sdlpoints(points.size());
 
-    for (unsigned i = 0; i < points.size(); ++i) {
+    for (unsigned i = 0; i < points.size(); ++i)
         sdlpoints[i] = {points[i].x(), points[i].y()};
-    }
 
-    if (SDL_RenderDrawLines(m_renderer.get(), sdlpoints.data(), sdlpoints.size()) < 0) {
+    if (SDL_RenderDrawLines(renderer_.get(), sdlpoints.data(), sdlpoints.size()) < 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::draw_point(const point& point)
 {
-    if (SDL_RenderDrawPoint(m_renderer.get(), point.x(), point.y()) != 0) {
+    if (SDL_RenderDrawPoint(renderer_.get(), point.x(), point.y()) != 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::draw_points(const std::vector<point>& points)
 {
     std::vector<SDL_Point> sdlpoints(points.size());
 
-    for (unsigned i = 0; i < points.size(); ++i) {
+    for (unsigned i = 0; i < points.size(); ++i)
         sdlpoints[i] = {points[i].x(), points[i].y()};
-    }
 
-    if (SDL_RenderDrawPoints(m_renderer.get(), sdlpoints.data(), sdlpoints.size()) != 0) {
+    if (SDL_RenderDrawPoints(renderer_.get(), sdlpoints.data(), sdlpoints.size()) != 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::draw_rectangle(const rectangle& rectangle)
@@ -538,9 +495,8 @@
         static_cast<int>(rectangle.height())
     };
 
-    if (SDL_RenderDrawRect(m_renderer.get(), &rect) < 0) {
+    if (SDL_RenderDrawRect(renderer_.get(), &rect) < 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::draw_rectangles(const std::vector<rectangle>& rectangles)
@@ -556,9 +512,8 @@
         };
     }
 
-    if (SDL_RenderDrawRects(m_renderer.get(), sdlrects.data(), sdlrects.size()) != 0) {
+    if (SDL_RenderDrawRects(renderer_.get(), sdlrects.data(), sdlrects.size()) != 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::fill_rectangle(const rectangle& rectangle)
@@ -570,9 +525,8 @@
         static_cast<int>(rectangle.height())
     };
 
-    if (SDL_RenderFillRect(m_renderer.get(), &rect) < 0) {
+    if (SDL_RenderFillRect(renderer_.get(), &rect) < 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::fill_rectangles(const std::vector<rectangle>& rectangles)
@@ -588,18 +542,17 @@
         };
     }
 
-    if (SDL_RenderFillRects(m_renderer.get(), sdlrects.data(), sdlrects.size()) != 0) {
+    if (SDL_RenderFillRects(renderer_.get(), sdlrects.data(), sdlrects.size()) != 0)
         throw std::runtime_error(SDL_GetError());
-    }
 }
 
 void window::backend_impl::draw_text(const std::string& text, font& font, const rectangle& rectangle)
 {
     SDL_Color color = {0, 0, 0, 255};
     SDL_Surface* message = TTF_RenderUTF8_Blended(font.backend().font(), text.c_str(), color);
-    SDL_Texture* texture = SDL_CreateTextureFromSurface(m_renderer.get(), message);
+    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer_.get(), message);
     SDL_Rect rect = {rectangle.x(), rectangle.y(), (int)rectangle.width(), (int)rectangle.height()};
-    SDL_RenderCopy(m_renderer.get(), texture, nullptr, &rect);
+    SDL_RenderCopy(renderer_.get(), texture, nullptr, &rect);
     SDL_FreeSurface(message);
     SDL_DestroyTexture(texture);
 }
@@ -607,11 +560,11 @@
 void window::backend_impl::draw_text(const std::string &text, font& font, const point& point)
 {
     SDL_Color color = {0, 0, 0, 0};
-    SDL_GetRenderDrawColor(m_renderer.get(), &color.r, &color.g, &color.b, &color.a);
+    SDL_GetRenderDrawColor(renderer_.get(), &color.r, &color.g, &color.b, &color.a);
     SDL_Surface* message = TTF_RenderUTF8_Blended(font.backend().font(), text.c_str(), color);
-    SDL_Texture* texture = SDL_CreateTextureFromSurface(m_renderer.get(), message);
+    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer_.get(), message);
     SDL_Rect rect = {point.x(), point.y(), message->w, message->h};
-    SDL_RenderCopy(m_renderer.get(), texture, nullptr, &rect);
+    SDL_RenderCopy(renderer_.get(), texture, nullptr, &rect);
     SDL_FreeSurface(message);
     SDL_DestroyTexture(texture);
 }

--- a/libclient/malikania/client/backend/sdl/window_backend.hpp	Wed Sep 27 12:52:36 2017 +0200
+++ b/libclient/malikania/client/backend/sdl/window_backend.hpp	Wed Sep 27 20:06:48 2017 +0200
@@ -32,8 +32,8 @@
 
 class window::backend_impl {
 private:
-    std::unique_ptr<SDL_Window, void (*)(SDL_Window *)> m_window;
-    std::unique_ptr<SDL_Renderer, void (*)(SDL_Renderer *)> m_renderer;
+    std::unique_ptr<SDL_Window, void (*)(SDL_Window *)> window_;
+    std::unique_ptr<SDL_Renderer, void (*)(SDL_Renderer *)> renderer_;
 
     void handle_key(window&, const SDL_Event&);
     void handle_mouse(window&, const SDL_Event&);
@@ -45,7 +45,7 @@
 
     inline SDL_Renderer* renderer() noexcept
     {
-        return m_renderer.get();
+        return renderer_.get();
     }
 
     void start_edit();