text: /*
   * Copyright (C) 2016 Simon Fels <morphis@gravedo.de>
   *
   * This program is free software: you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 3, as published
   * by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranties of
   * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
   * PURPOSE.  See the GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License along
   * with this program.  If not, see <http://www.gnu.org/licenses/>.
   *
   */
  
  #include "anbox/platform/sdl/window.h"
  #include "anbox/wm/window_state.h"
  #include "anbox/graphics/density.h"
  #include "anbox/logger.h"
  
  #include <boost/throw_exception.hpp>
  
  #if defined(MIR_SUPPORT)
  #include <mir_toolkit/mir_client_library.h>
  #endif
  
  namespace {
  constexpr const int window_resize_border{10};
  constexpr const int top_drag_area{42};
  constexpr const int button_size{32};
  constexpr const int button_margin{5};
  constexpr const int button_padding{0};
  }
  
  namespace anbox {
  namespace platform {
  namespace sdl {
  Window::Id Window::Invalid{-1};
  
  Window::Observer::~Observer() {}
  
  Window::Window(const std::shared_ptr<Renderer> &renderer,
                 const Id &id, const wm::Task::Id &task,
                 const std::shared_ptr<Observer> &observer,
                 const graphics::Rect &frame,
                 const std::string &title,
                 bool resizable,
                 bool borderless)
      : wm::Window(renderer, task, frame, title),
        id_(id),
        observer_(observer),
        native_display_(0),
        native_window_(0) {
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
  
    // NOTE: We don't furce GL initialization of the window as this will
    // be take care of by the Renderer when we attach to it. On EGL
    // initializing GL here will cause a surface to be created and the
    // renderer will attempt to create one too which will not work as
    // only a single surface per EGLNativeWindowType is supported.
    std::uint32_t flags = 0;
    if (borderless)
      flags |= SDL_WINDOW_BORDERLESS;
    if (resizable)
      flags |= SDL_WINDOW_RESIZABLE;
  
    window_ = SDL_CreateWindow(title.c_str(),
                               frame.left(), frame.top(),
                               frame.width(), frame.height(),
                               flags);
    if (!window_) {
      const auto message = utils::string_format("Failed to create window: %s", SDL_GetError());
      BOOST_THROW_EXCEPTION(std::runtime_error(message));
    }
  
    // If we create a window with border (server-side decoration), We
    // should not set hit test handler beacuse we don't need to simulate
    // the behavior of the title bar and resize area.
    if (borderless && utils::get_env_value("ANBOX_NO_SDL_WINDOW_HIT_TEST", "false") == "false")
      if (SDL_SetWindowHitTest(window_, &Window::on_window_hit, this) < 0)
        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to register for window hit test"));
  
    SDL_SysWMinfo info;
    SDL_VERSION(&info.version);
    SDL_GetWindowWMInfo(window_, &info);
    switch (info.subsystem) {
  #if defined(X11_SUPPORT)
      case SDL_SYSWM_X11:
        native_display_ = static_cast<EGLNativeDisplayType>(info.info.x11.display);
        native_window_ = static_cast<EGLNativeWindowType>(info.info.x11.window);
        break;
  #endif
  #if defined(WAYLAND_SUPPORT)
      case SDL_SYSWM_WAYLAND:
        native_display_ = reinterpret_cast<EGLNativeDisplayType>(info.info.wl.display);
        native_window_ = reinterpret_cast<EGLNativeWindowType>(info.info.wl.surface);
        break;
  #endif
  #if defined(MIR_SUPPORT)
      case SDL_SYSWM_MIR: {
        native_display_ = static_cast<EGLNativeDisplayType>(mir_connection_get_egl_native_display(info.info.mir.connection));
        auto buffer_stream = mir_surface_get_buffer_stream(info.info.mir.surface);
        native_window_ = reinterpret_cast<EGLNativeWindowType>(mir_buffer_stream_get_egl_native_window(buffer_stream));
        break;
      }
  #endif
      default:
        ERROR("Unknown subsystem (%d)", info.subsystem);
        BOOST_THROW_EXCEPTION(std::runtime_error("SDL subsystem not supported"));
    }
  
    SDL_ShowWindow(window_);
  }
  
  Window::~Window() {
    if (window_) SDL_DestroyWindow(window_);
  }
  
  SDL_HitTestResult Window::on_window_hit(SDL_Window *window, const SDL_Point *pt, void *data) {
    auto platform_window = reinterpret_cast<Window*>(data);
  
    int w = 0, h = 0;
    SDL_GetWindowSize(window, &w, &h);
  
    const auto border_size = graphics::dp_to_pixel(window_resize_border);
    const auto top_drag_area_height = graphics::dp_to_pixel(top_drag_area);
    const auto button_area_width = graphics::dp_to_pixel(button_size + button_padding * 2 + button_margin * 2);
    const auto flags = SDL_GetWindowFlags(window);
  
    if (flags & SDL_WINDOW_FULLSCREEN)
        return SDL_HITTEST_NORMAL;
  
    if (!(flags & SDL_WINDOW_RESIZABLE)) {
      if (pt->y < border_size)
        return SDL_HITTEST_DRAGGABLE;
      else
        return SDL_HITTEST_NORMAL;
    }
  
    if (pt->y < top_drag_area_height) {
      if (pt->x > w - button_area_width && pt->x < w) {
        platform_window->close();
        return SDL_HITTEST_NORMAL;
      } else if (pt->x > w - button_area_width * 2 && pt->x < w - button_area_width) {
        platform_window->switch_window_state();
        return SDL_HITTEST_NORMAL;
      }
      return SDL_HITTEST_DRAGGABLE;
    }
  
    if (flags & SDL_WINDOW_MAXIMIZED)
      return SDL_HITTEST_NORMAL;
  
    if (pt->x < border_size && pt->y < border_size)
        return SDL_HITTEST_RESIZE_TOPLEFT;
    else if (pt->x > border_size && pt->x < w - border_size && pt->y < border_size)
        return SDL_HITTEST_RESIZE_TOP;
    else if (pt->x > w - border_size && pt->y < border_size)
        return SDL_HITTEST_RESIZE_TOPRIGHT;
    else if (pt->x > w - border_size && pt->y > border_size && pt->y < h - border_size)
        return SDL_HITTEST_RESIZE_RIGHT;
    else if (pt->x > w - border_size && pt->y > h - border_size)
        return SDL_HITTEST_RESIZE_BOTTOMRIGHT;
    else if (pt->x < w - border_size && pt->x > border_size && pt->y > h - border_size)
        return SDL_HITTEST_RESIZE_BOTTOM;
    else if (pt->x < border_size && pt->y > h - border_size)
        return SDL_HITTEST_RESIZE_BOTTOMLEFT;
    else if (pt->x < border_size && pt->y < h - border_size && pt->y > border_size)
        return SDL_HITTEST_RESIZE_LEFT;
  
    return SDL_HITTEST_NORMAL;
  }
  
  void Window::close() {
    if (observer_)
      observer_->window_deleted(id_);
  }
  
  void Window::switch_window_state() {
    const auto flags = SDL_GetWindowFlags(window_);
    if (flags & SDL_WINDOW_MAXIMIZED)
      SDL_RestoreWindow(window_);
    else
      SDL_MaximizeWindow(window_);
  }
  
  void Window::process_event(const SDL_Event &event) {
    switch (event.window.event) {
      case SDL_WINDOWEVENT_FOCUS_GAINED:
        if (observer_) observer_->window_wants_focus(id_);
        break;
      case SDL_WINDOWEVENT_FOCUS_LOST:
        break;
      // Not need to listen for SDL_WINDOWEVENT_RESIZED here as the
      // SDL_WINDOWEVENT_SIZE_CHANGED is always sent.
      case SDL_WINDOWEVENT_SIZE_CHANGED:
        if (observer_)
          observer_->window_resized(id_, event.window.data1, event.window.data2);
        break;
      case SDL_WINDOWEVENT_MOVED:
        if (observer_)
          observer_->window_moved(id_, event.window.data1, event.window.data2);
        break;
      case SDL_WINDOWEVENT_SHOWN:
        break;
      case SDL_WINDOWEVENT_HIDDEN:
        break;
      case SDL_WINDOWEVENT_CLOSE:
        close();
        break;
      default:
        break;
    }
  }
  
  EGLNativeWindowType Window::native_handle() const { return native_window_; }
  
  Window::Id Window::id() const { return id_; }
  
  std::uint32_t Window::window_id() const { return SDL_GetWindowID(window_); }
  } // namespace sdl
  } // namespace platform
  } // namespace anbox
  