Subversion Repositories DIN Is Noise

/*

* slider.h

* DIN Is Noise is copyright (c) 2006-2025 Jagannathan Sampath

* For more information, please visit http://dinisnoise.org/

*/

#ifndef __slider

#define __slider

#include "widget.h"

#include "viewwin.h"

#include "utils.h"

#include "filled_button.h"

#include "input.h"

#include <algorithm>

#include <vector>

extern int mousex;

extern viewport view;

extern int lmb;

template <typename S> struct after_slide_lis {

  virtual void slided (S& s) = 0;

};

template <typename S> struct start_slide_lis {

  virtual void start_slide (S& s) = 0;

};

template <typename T> struct values {

  T low, high, delta, val;

  float amount;

  values (T l = 0, T h = 1, T v = 0) {

    set_limits (l, h);

    *this = v;

  }

  operator T() {

    return ((T) val);

  }

  void set_limits (T l, T h) {

    low = l;

    high = h;

    delta = high - low;

  }

  void get_limits (T& l, T& h) {

    l = low;

    h = high;

  }

  T operator() () const { return val; }

  values& operator= (const T& v) {

    val = v;

    clamp<T> (low, val, high);

    if (delta) amount = (val - low) * 1.0f / delta; else amount = 0;

    return *this;

  }

  void set_amount (float a) {

    amount = a;

    clamp<float> (0.0f, amount, 1.0f);

    val = (T) (low + delta * amount);

  }

  float get_amount () const { return amount; }

};

template <typename T> struct slider : widget, move_listener {

  values<T> vx;

  int dx;

  std::vector<int> dxa;

  int sliding;

  int lmb_clicked;

  change_listener<slider> *chgl;

  after_slide_lis<slider> *asl;

  start_slide_lis<slider> *ssl;

  filled_button sizer;

  static const int spc = 10;

  slider (int sv = 0, int w = 64, int h = 16) : widget (0, 0, w, h), vx (0, 0, 0), sliding(0), lmb_clicked(0) {

    chgl = 0;

    asl = 0;

    set_sizer_visible (sv);

  }

  void set_sizer_visible (int sv) {

    sizer.visible = sv;

    if (sizer.visible) {

      sizer.set_moveable (1);

      sizer.movlis = this;

    } else {

      sizer.set_moveable (0);

      sizer.movlis = 0;

    }

  }

  void set_pos (int x, int y) {

    widget::set_pos (x, y);

    sizer.set_pos (extents.right + spc, extents.bottom);

  }

  void set_right (int r) {

    set_extents (extents.left, extents.bottom, r, extents.top);

    dx = vx.get_amount () * extents.width;

  }

  void set_size (int w) {

    set_extents (extents.left, extents.bottom, extents.left + w, extents.top);

    dx = vx.get_amount () * extents.width;

  }

  void moved () {

    int mpx = mousex - movr.prevx;

    if (mpx) {

      sizer.set_pos (mousex, extents.bottom);

      int msx = mousex - spc;

      if (msx > extents.left) set_right (msx);

    }

  }

  int handle_input () {

    widget::handle_input ();

    if (sizer.visible && sizer.handle_input ()) return 1;

    int ret = 0;

    if (lmb) {

      if (lmb_clicked == 0) {

        if (sliding) {

          sliding = 0;

          if (asl) asl->slided (*this);

          defocus (this);

          ret = 1;

        } else {

          if (hover) {

            sliding = 1;

            if (ssl) ssl->start_slide (*this);

            widget::focus = this;

            ret = 1;

          }

        }

        lmb_clicked = 1;

      }

    } else {

      if (sliding) {

        int nu_dx = mousex - extents.left;

        clamp (0, nu_dx, extents.width);

        if (nu_dx != dx) {

          dx = nu_dx;

          vx.set_amount (dx * extents.width_1);

          if (chgl) chgl->changed (*this);

        }

        if (keypressed(SDLK_f)) dxa.push_back (dx);

        if (keypressed(SDLK_BACKSPACE)) dxa.clear ();

      } else

        ret = 0;

      lmb_clicked = 0;

    }

    return ret;

  }

  void draw () {

    widget::draw ();

    glEnable (GL_BLEND);

    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    const color& c = clr;

    glColor4f (c.r, c.g, c.b, (GLfloat) 0.25);

    const box<int>& e = extents;

      glRecti (e.left, e.bottom, e.right, e.top);

    glColor4f (c.r, c.g, c.b, GLfloat (1));

      glRecti (e.left, e.bottom, e.left + dx, e.top);

    glDisable (GL_BLEND);

    glColor3f (1, 1, 1);

    for (int i = 0, j = dxa.size (); i < j; ++i) {

      int dxi = extents.left + dxa[i];

      glBegin (GL_LINES);

        glVertex2i (dxi, extents.top + spc);

        glVertex2i (dxi, extents.bottom - spc);

      glEnd ();

    }

    if (sizer.visible) sizer.draw ();

  }

  void update () {

    float amount = vx.get_amount ();

    const box<int>& e = extents;

    dx = (int) (amount * e.width);  

  }

  void set_listener (change_listener<slider>* _chgl, start_slide_lis<slider>* _ssl = 0, after_slide_lis<slider>* _asl = 0) {

    chgl = _chgl;

    ssl = _ssl;

    asl = _asl;

  }

  T operator() () const {return vx (); }

  void set_val (const T& t) {

    vx = t;

    update ();

  }

  void set_limits (T l, T h) {

    vx = values<T> (l, h, vx());

    update ();

  }

  void get_limits (T& l, T& h) {

    vx.get_limits (l, h);

  }

};

#define MAKE_SLIDER_LISTENER(name,var) struct name : change_listener< slider<float> > { void changed (slider<float>& s); }; name var;

#define SLIDER_CHANGED(scope,name) void scope::name::changed (slider<float>& s)

#define MAKE_AFTER_SLIDE_LISTENER(name,type,var) struct name : after_slide_lis< type > { void slided (type& s); }; name var;

#define SLIDED(scope,name,type) void scope::name::slided (type& s)

#define MAKE_START_SLIDE_LISTENER(name,type,var) struct name : start_slide_lis< type > { void start_slide (type& s); }; name var;

#define START_SLIDE(scope,name,type) void scope::name::start_slide (type& s)

#endif