path: root/extension/src/openvic-extension/classes/GUIScrollbar.cpp

#include "GUIScrollbar.hpp"

#include <godot_cpp/classes/input_event_mouse_button.hpp>
#include <godot_cpp/classes/input_event_mouse_motion.hpp>
#include <godot_cpp/variant/utility_functions.hpp>

#include "openvic-extension/utility/ClassBindings.hpp"
#include "openvic-extension/utility/UITools.hpp"
#include "openvic-extension/utility/Utilities.hpp"

using namespace OpenVic;
using namespace godot;

using OpenVic::Utilities::std_to_godot_string;
using OpenVic::Utilities::std_view_to_godot_string;

/* StringNames cannot be constructed until Godot has called StringName::setup(),
 * so we must use wrapper functions to delay their initialisation. */
StringName const& GUIScrollbar::signal_value_changed() {
   static const StringName signal_value_changed = "value_changed";
   return signal_value_changed;
}

void GUIScrollbar::_bind_methods() {
   OV_BIND_METHOD(GUIScrollbar::emit_value_changed);
   OV_BIND_METHOD(GUIScrollbar::reset);
   OV_BIND_METHOD(GUIScrollbar::clear);

   OV_BIND_METHOD(GUIScrollbar::set_gui_scrollbar_name, { "gui_scene", "gui_scrollbar_name" });
   OV_BIND_METHOD(GUIScrollbar::get_gui_scrollbar_name);

   OV_BIND_METHOD(GUIScrollbar::get_orientation);

   OV_BIND_METHOD(GUIScrollbar::get_value);
   OV_BIND_METHOD(GUIScrollbar::get_value_as_ratio);
   OV_BIND_METHOD(GUIScrollbar::get_min_value);
   OV_BIND_METHOD(GUIScrollbar::get_max_value);
   OV_BIND_METHOD(GUIScrollbar::set_value, { "new_value", "signal" }, DEFVAL(true));
   OV_BIND_METHOD(GUIScrollbar::set_value_as_ratio, { "new_ratio", "signal" }, DEFVAL(true));

   OV_BIND_METHOD(GUIScrollbar::is_range_limited);
   OV_BIND_METHOD(GUIScrollbar::get_range_limit_min);
   OV_BIND_METHOD(GUIScrollbar::get_range_limit_max);
   OV_BIND_METHOD(GUIScrollbar::set_range_limits, { "new_range_limit_min", "new_range_limit_max", "signal" }, DEFVAL(true));
   OV_BIND_METHOD(GUIScrollbar::set_limits, { "new_min_value", "new_max_value", "signal" }, DEFVAL(true));

   OV_BIND_METHOD(GUIScrollbar::get_length_override);
   OV_BIND_METHOD(GUIScrollbar::set_length_override, { "new_length_override" });

   ADD_SIGNAL(MethodInfo(signal_value_changed(), PropertyInfo(Variant::INT, "value")));
}

GUIScrollbar::GUIScrollbar() {
   /* Anything which the constructor might not have default initialised will be set by clear(). */
   clear();
}

void GUIScrollbar::_start_button_change(bool shift_pressed, bool control_pressed) {
   if (shift_pressed) {
      if (control_pressed) {
         button_change_value_base = max_value - min_value;
      } else {
         button_change_value_base = 10;
      }
   } else {
      if (control_pressed) {
         button_change_value_base = 100;
      } else {
         button_change_value_base = 1;
      }
   }
   if (orientation == HORIZONTAL) {
      button_change_value_base = -button_change_value_base;
   }
   button_change_value = 0;
   button_change_accelerate_timer = BUTTON_CHANGE_ACCELERATE_DELAY;
   button_change_timer = BUTTON_CHANGE_DELAY;
   set_physics_process_internal(true);
}

void GUIScrollbar::_stop_button_change() {
   /* This ensures value always changes by at least 1 if less/more is pressed. */
   if (button_change_value == 0) {
      button_change_value = button_change_value_base;
      _update_button_change();
   }
   set_physics_process_internal(false);
}

bool GUIScrollbar::_update_button_change() {
   if (pressed_less) {
      set_value(value + button_change_value);
   } else if (pressed_more) {
      set_value(value - button_change_value);
   } else {
      return false;
   }
   return true;
}

float GUIScrollbar::_value_to_ratio(int32_t val) const {
   return min_value != max_value
      ? static_cast<float>(val - min_value) / (max_value - min_value)
      : 0.0f;
}

void GUIScrollbar::_calculate_rects() {
   update_minimum_size();

   const Size2 size = _get_minimum_size();

   if (orientation == HORIZONTAL) {
      slider_distance = size.width;

      if (less_texture.is_valid()) {
         less_rect = { {}, less_texture->get_size() };

         slider_distance -= less_rect.size.width;
      } else {
         less_rect = {};
      }

      if (more_texture.is_valid()) {
         const Size2 more_size = more_texture->get_size();

         more_rect = { { size.width - more_size.width, 0.0f }, more_size };

         slider_distance -= more_rect.size.width;
      } else {
         more_rect = {};
      }

      slider_start = less_rect.size.width;

      if (track_texture.is_valid()) {
         const real_t track_height = track_texture->get_height();

         track_rect = { { slider_start, 0.0f }, { slider_distance, track_height } };
      } else {
         track_rect = {};
      }

      if (slider_texture.is_valid()) {
         slider_rect = { {}, slider_texture->get_size() };

         slider_distance -= slider_rect.size.width;
      } else {
         slider_rect = {};
      }
   } else { /* VERTICAL */
      slider_distance = size.height;

      if (less_texture.is_valid()) {
         const Size2 less_size = less_texture->get_size();

         less_rect = { { 0.0f, size.height - less_size.height }, less_size };

         slider_distance -= less_rect.size.height;
      } else {
         less_rect = {};
      }

      if (more_texture.is_valid()) {
         more_rect = { {}, more_texture->get_size() };

         slider_distance -= more_rect.size.height;
      } else {
         more_rect = {};
      }

      slider_start = more_rect.size.height;
      const real_t average_button_width = (more_rect.size.width + less_rect.size.width) / 2.0f;

      if (track_texture.is_valid()) {
         const real_t track_width = track_texture->get_width();

         /* For some reason vertical scrollbar track textures overlap with their more buttons by a single pixel.
          * They have a row of transparent pixels at the top to account for this, so we must also draw them
          * one pixel taller to avoid having a gap between the track and the more button. */
         track_rect = {
            { (average_button_width - track_width) / 2.0f, slider_start - 1.0f },
            { track_width, slider_distance + 1.0f }
         };
      } else {
         track_rect = {};
      }

      if (slider_texture.is_valid()) {
         const Size2 slider_size = slider_texture->get_size();

         slider_rect = {
            { (average_button_width - slider_size.width) / 2.0f, 0.0f },
            slider_size
         };

         slider_distance -= slider_rect.size.height;
      } else {
         slider_rect = {};
      }
   }

   if (range_limit_min_texture.is_valid()) {
      range_limit_min_rect = { {}, range_limit_min_texture->get_size() };
   } else {
      range_limit_min_rect = {};
   }

   if (range_limit_max_texture.is_valid()) {
      range_limit_max_rect = { {}, range_limit_max_texture->get_size() };
   } else {
      range_limit_max_rect = {};
   }
}

void GUIScrollbar::_constrain_value() {
   /* Clamp using range limits, as even when range limiting is disabled the limits will be set to min/max values. */
   value = std::clamp(value, range_limit_min, range_limit_max);

   slider_rect.position[orientation == HORIZONTAL ? 0 : 1] = slider_start + slider_distance * get_value_as_ratio();

   queue_redraw();
}

/* _constrain_value() should be called sometime after this. */
Error GUIScrollbar::_constrain_range_limits() {
   if (range_limited) {
      range_limit_min = std::clamp(range_limit_min, min_value, max_value);
      range_limit_max = std::clamp(range_limit_max, min_value, max_value);

      Error err = OK;
      if (range_limit_min > range_limit_max) {
         UtilityFunctions::push_error(
            "GUIScrollbar range max ", range_limit_max, " is less than range min ", range_limit_min, " - swapping values."
         );
         std::swap(range_limit_min, range_limit_max);
         err = FAILED;
      }

      const int axis = orientation == HORIZONTAL ? 0 : 1;
      range_limit_min_rect.position[axis] = slider_start + slider_distance * _value_to_ratio(range_limit_min);
      range_limit_max_rect.position[axis] = slider_start + slider_distance * _value_to_ratio(range_limit_max)
         + slider_rect.size[axis] / 2.0f;

      return err;
   } else {
      range_limit_min = min_value;
      range_limit_max = max_value;
      return OK;
   }
}

/* _constrain_range_limits() should be called sometime after this. */
Error GUIScrollbar::_constrain_limits() {
   if (min_value <= max_value) {
      return OK;
   } else {
      UtilityFunctions::push_error(
         "GUIScrollbar max value ", max_value, " is less than min value ", min_value, " - swapping values."
      );
      std::swap(min_value, max_value);
      return FAILED;
   }
}

Vector2 GUIScrollbar::_get_minimum_size() const {
   if (gui_scrollbar != nullptr) {
      Size2 size = Utilities::to_godot_fvec2(gui_scrollbar->get_size());

      const int axis = orientation == HORIZONTAL ? 1 : 0;
      if (less_texture.is_valid()) {
         size[axis] = std::max(size[axis], less_texture->get_size()[axis]);
      }
      if (more_texture.is_valid()) {
         size[axis] = std::max(size[axis], more_texture->get_size()[axis]);
      }

      if (length_override > 0.0f) {
         size[1 - axis] = length_override;
      }

      return size;
   } else {
      return {};
   }
}

void GUIScrollbar::emit_value_changed() {
   emit_signal(signal_value_changed(), value);
}

Error GUIScrollbar::reset() {
   set_physics_process_internal(false);
   button_change_accelerate_timer = 0.0;
   button_change_timer = 0.0;
   button_change_value_base = 0;
   button_change_value = 0;

   hover_slider = false;
   hover_track = false;
   hover_less = false;
   hover_more = false;
   pressed_slider = false;
   pressed_track = false;
   pressed_less = false;
   pressed_more = false;

   value = min_value;
   range_limit_min = min_value;
   range_limit_max = max_value;

   const Error err = _constrain_range_limits();
   _constrain_value();
   emit_value_changed();
   return err;
}

void GUIScrollbar::clear() {
   gui_scrollbar = nullptr;

   slider_texture.unref();
   track_texture.unref();
   less_texture.unref();
   more_texture.unref();

   slider_rect = {};
   track_rect = {};
   less_rect = {};
   more_rect = {};

   range_limit_min_texture.unref();
   range_limit_max_texture.unref();

   range_limit_min_rect = {};
   range_limit_max_rect = {};

   orientation = HORIZONTAL;
   length_override = 0.0f;
   min_value = 0;
   max_value = 100;
   range_limited = false;

   _calculate_rects();

   _constrain_limits();
   reset();
}

Error GUIScrollbar::set_gui_scrollbar(GUI::Scrollbar const* new_gui_scrollbar) {
   if (gui_scrollbar == new_gui_scrollbar) {
      return OK;
   }
   if (new_gui_scrollbar == nullptr) {
      clear();
      return OK;
   }

   bool ret = true;

   gui_scrollbar = new_gui_scrollbar;

   const String gui_scrollbar_name = std_view_to_godot_string(gui_scrollbar->get_name());

   orientation = gui_scrollbar->is_horizontal() ? HORIZONTAL : VERTICAL;
   length_override = 0.0f;
   range_limited = gui_scrollbar->is_range_limited();

   /* _Element is either GUI::Button or GUI::Icon, both of which have their own
    * separately defined get_sprite(), hence the need for a template. */
   const auto set_texture = [&gui_scrollbar_name]<typename _Element>(
      String const& target, _Element const* element, Ref<GFXSpriteTexture>& texture
   ) -> bool {
      ERR_FAIL_NULL_V_MSG(element, false, vformat(
         "Invalid %s element for GUIScrollbar %s - null!", target, gui_scrollbar_name
      ));
      const String element_name = std_view_to_godot_string(element->get_name());

      /* Get Sprite, convert to TextureSprite, use to make a GFXSpriteTexture. */
      GFX::Sprite const* sprite = element->get_sprite();
      ERR_FAIL_NULL_V_MSG(sprite, false, vformat(
         "Invalid %s element %s for GUIScrollbar %s - sprite is null!", target, element_name, gui_scrollbar_name
      ));
      GFX::TextureSprite const* texture_sprite = sprite->cast_to<GFX::TextureSprite>();
      ERR_FAIL_NULL_V_MSG(texture_sprite, false, vformat(
         "Invalid %s element %s for GUIScrollbar %s - sprite type is %s with base type %s, expected base %s!", target,
         element_name, gui_scrollbar_name, std_view_to_godot_string(sprite->get_type()),
         std_view_to_godot_string(sprite->get_base_type()), std_view_to_godot_string(GFX::TextureSprite::get_type_static())
      ));
      texture = GFXSpriteTexture::make_gfx_sprite_texture(texture_sprite);
      ERR_FAIL_NULL_V_MSG(texture, false, vformat(
         "Failed to make GFXSpriteTexture from %s element %s for GUIScrollbar %s!", target, element_name, gui_scrollbar_name
      ));
      if constexpr (std::is_same_v<_Element, GUI::Button>) {
         using enum GFXButtonStateTexture::ButtonState;
         for (GFXButtonStateTexture::ButtonState state : { HOVER, PRESSED }) {
            ERR_FAIL_NULL_V_MSG(texture->get_button_state_texture(state), false, vformat(
               "Failed to generate %s texture for %s element %s for GUIScrollbar %s!",
               GFXButtonStateTexture::button_state_to_theme_name(state), target, element_name, gui_scrollbar_name
            ));
         }
      }
      return true;
   };

   static const String SLIDER_NAME = "slider";
   static const String TRACK_NAME = "track";
   static const String LESS_NAME = "less";
   static const String MORE_NAME = "more";
   static const String RANGE_LIMIT_MIN_NAME = "range limit min";
   static const String RANGE_LIMIT_MAX_NAME = "range limit max";

   ret &= set_texture(SLIDER_NAME, gui_scrollbar->get_slider_button(), slider_texture);
   ret &= set_texture(TRACK_NAME, gui_scrollbar->get_track_button(), track_texture);
   ret &= set_texture(LESS_NAME, gui_scrollbar->get_less_button(), less_texture);
   ret &= set_texture(MORE_NAME, gui_scrollbar->get_more_button(), more_texture);
   if (range_limited) {
      ret &= set_texture(RANGE_LIMIT_MIN_NAME, gui_scrollbar->get_range_limit_min_icon(), range_limit_min_texture);
      ret &= set_texture(RANGE_LIMIT_MAX_NAME, gui_scrollbar->get_range_limit_max_icon(), range_limit_max_texture);
   } else {
      range_limit_min_texture.unref();
      range_limit_max_texture.unref();
   }

   _calculate_rects();

   fixed_point_t step_size = gui_scrollbar->get_step_size();
   if (step_size <= 0) {
      UtilityFunctions::push_error(
         "Invalid step size ", std_to_godot_string(step_size.to_string()), " for GUIScrollbar ", gui_scrollbar_name,
         " - not positive! Defaulting to 1."
      );
      step_size = 1;
      ret = false;
   }
   min_value = gui_scrollbar->get_min_value() / step_size;
   max_value = gui_scrollbar->get_max_value() / step_size;

   ret &= _constrain_limits() == OK;
   ret &= reset() == OK;

   return ERR(ret);
}

Error GUIScrollbar::set_gui_scrollbar_name(String const& gui_scene, String const& gui_scrollbar_name) {
   if (gui_scene.is_empty() && gui_scrollbar_name.is_empty()) {
      return set_gui_scrollbar(nullptr);
   }
   ERR_FAIL_COND_V_MSG(gui_scene.is_empty() || gui_scrollbar_name.is_empty(), FAILED, "GUI scene or scrollbar name is empty!");

   GUI::Element const* gui_element = UITools::get_gui_element(gui_scene, gui_scrollbar_name);
   ERR_FAIL_NULL_V(gui_element, FAILED);
   GUI::Scrollbar const* new_gui_scrollbar = gui_element->cast_to<GUI::Scrollbar>();
   ERR_FAIL_NULL_V(new_gui_scrollbar, FAILED);
   return set_gui_scrollbar(new_gui_scrollbar);
}

String GUIScrollbar::get_gui_scrollbar_name() const {
   return gui_scrollbar != nullptr ? std_view_to_godot_string(gui_scrollbar->get_name()) : String {};
}

void GUIScrollbar::set_value(int32_t new_value, bool signal) {
   const int32_t old_value = value;
   value = new_value;
   _constrain_value();
   if (signal && value != old_value) {
      emit_value_changed();
   }
}

float GUIScrollbar::get_value_as_ratio() const {
   return _value_to_ratio(value);
}

void GUIScrollbar::set_value_as_ratio(float new_ratio, bool signal) {
   set_value(min_value + (max_value - min_value) * new_ratio, signal);
}

Error GUIScrollbar::set_range_limits(int32_t new_range_limit_min, int32_t new_range_limit_max, bool signal) {
   ERR_FAIL_COND_V_MSG(!range_limited, FAILED, "Cannot set range limits of non-range-limited GUIScrollbar!");
   range_limit_min = new_range_limit_min;
   range_limit_max = new_range_limit_max;
   const Error err = _constrain_range_limits();
   set_value(value, signal);
   return err;
}

Error GUIScrollbar::set_limits(int32_t new_min_value, int32_t new_max_value, bool signal) {
   min_value = new_min_value;
   max_value = new_max_value;
   bool ret = _constrain_limits() == OK;
   ret &= _constrain_range_limits() == OK;
   set_value(value, signal);
   return ERR(ret);
}

void GUIScrollbar::set_length_override(real_t new_length_override) {
   ERR_FAIL_COND_MSG(
      length_override < 0, vformat("Invalid GUIScrollbar length override: %f - cannot be negative!", length_override)
   );

   length_override = new_length_override;

   _calculate_rects();
   _constrain_limits();
   _constrain_range_limits();
   _constrain_value();
}

void GUIScrollbar::_gui_input(Ref<InputEvent> const& event) {
   ERR_FAIL_NULL(event);

   Ref<InputEventMouseButton> mb = event;

   if (mb.is_valid()) {
      if (mb->get_button_index() == MouseButton::MOUSE_BUTTON_LEFT) {
         if (mb->is_pressed()) {
            if (less_rect.has_point(mb->get_position())) {
               pressed_less = true;
               _start_button_change(mb->is_shift_pressed(), mb->is_ctrl_pressed());
            } else if (more_rect.has_point(mb->get_position())) {
               pressed_more = true;
               _start_button_change(mb->is_shift_pressed(), mb->is_ctrl_pressed());
            } else if (slider_rect.has_point(mb->get_position())) {
               pressed_slider = true;
            } else if (track_rect.has_point(mb->get_position())) {
               pressed_track = true;
               const real_t click_pos = mb->get_position()[orientation == HORIZONTAL ? 0 : 1];
               set_value_as_ratio((click_pos - slider_start) / slider_distance);
            } else {
               return;
            }
         } else {
            if (pressed_less) {
               _stop_button_change();
               pressed_less = false;
            } else if (pressed_more) {
               _stop_button_change();
               pressed_more = false;
            } else if (pressed_slider) {
               pressed_slider = false;
            } else if (pressed_track) {
               pressed_track = false;
            } else {
               return;
            }
         }
         queue_redraw();
      }
      return;
   }

   Ref<InputEventMouseMotion> mm = event;

   if (mm.is_valid()) {
      if (pressed_track) {
         /* Switch to moving the slider if a track click is held and moved. */
         pressed_track = false;
         pressed_slider = true;
      }
      if (pressed_slider) {
         const real_t click_pos = mm->get_position()[orientation == HORIZONTAL ? 0 : 1];
         set_value_as_ratio((click_pos - slider_start) / slider_distance);
      }

      if (hover_slider != slider_rect.has_point(mm->get_position())) {
         hover_slider = !hover_slider;
         queue_redraw();
      }
      if (hover_track != track_rect.has_point(mm->get_position())) {
         hover_track = !hover_track;
         queue_redraw();
      }
      if (hover_less != less_rect.has_point(mm->get_position())) {
         hover_less = !hover_less;
         queue_redraw();
      }
      if (hover_more != more_rect.has_point(mm->get_position())) {
         hover_more = !hover_more;
         queue_redraw();
      }
      return;
   }
}

void GUIScrollbar::_notification(int what) {
   switch (what) {
   case NOTIFICATION_VISIBILITY_CHANGED:
   case NOTIFICATION_MOUSE_EXIT: {
      hover_slider = false;
      hover_track = false;
      hover_less = false;
      hover_more = false;
      queue_redraw();
   } break;

   /* Pressing (and holding) less and more buttons. */
   case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
      const double delta = get_physics_process_delta_time();

      button_change_accelerate_timer -= delta;
      while (button_change_accelerate_timer <= 0.0) {
         button_change_accelerate_timer += BUTTON_CHANGE_ACCELERATE_DELAY;
         button_change_value += button_change_value_base;
      }

      button_change_timer -= delta;
      while (button_change_timer <= 0.0) {
         button_change_timer += BUTTON_CHANGE_DELAY;
         if (!_update_button_change()) {
            set_physics_process_internal(false);
         }
      }
   } break;

   case NOTIFICATION_DRAW: {
      const RID ci = get_canvas_item();

      using enum GFXButtonStateTexture::ButtonState;

      if (less_texture.is_valid()) {
         Ref<Texture2D> less_state_texture;
         if (pressed_less) {
            less_state_texture = less_texture->get_button_state_texture(PRESSED);
         } else if (hover_less) {
            less_state_texture = less_texture->get_button_state_texture(HOVER);
         }
         if (less_state_texture.is_null()) {
            less_state_texture = less_texture;
         }
         less_state_texture->draw_rect(ci, less_rect, false);
      }

      if (more_texture.is_valid()) {
         Ref<Texture2D> more_state_texture;
         if (pressed_more) {
            more_state_texture = more_texture->get_button_state_texture(PRESSED);
         } else if (hover_more) {
            more_state_texture = more_texture->get_button_state_texture(HOVER);
         }
         if (more_state_texture.is_null()) {
            more_state_texture = more_texture;
         }
         more_state_texture->draw_rect(ci, more_rect, false);
      }

      if (track_texture.is_valid()) {
         Ref<GFXCorneredTileSupportingTexture> track_state_texture;
         if (pressed_track) {
            track_state_texture = track_texture->get_button_state_texture(PRESSED);
         } else if (hover_track) {
            track_state_texture = track_texture->get_button_state_texture(HOVER);
         }
         if (track_state_texture.is_null()) {
            track_state_texture = track_texture;
         }
         track_state_texture->draw_rect_cornered(ci, track_rect);
      }

      if (slider_texture.is_valid()) {
         Ref<Texture2D> slider_state_texture;
         if (pressed_slider) {
            slider_state_texture = slider_texture->get_button_state_texture(PRESSED);
         } else if (hover_slider) {
            slider_state_texture = slider_texture->get_button_state_texture(HOVER);
         }
         if (slider_state_texture.is_null()) {
            slider_state_texture = slider_texture;
         }
         slider_state_texture->draw_rect(ci, slider_rect, false);
      }

      if (range_limited) {
         if (range_limit_min != min_value && range_limit_min_texture.is_valid()) {
            range_limit_min_texture->draw_rect(ci, range_limit_min_rect, false);
         }

         if (range_limit_max != max_value && range_limit_max_texture.is_valid()) {
            range_limit_max_texture->draw_rect(ci, range_limit_max_rect, false);
         }
      }
   } break;
   }
}