Scales.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */
#ifndef SCALE_H_
#define SCALE_H_

#include "Widget.H"
#include <mffm/LinkList.H>
#include <stdlib.h>
#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#endif
#include <math.h>
#include <limits>

#ifdef _MSC_VER
#ifndef MS_ROUND
double round(double number) {
    return number < 0.0 ? ceil(number - 0.5) : floor(number + 0.5);
}
#else
extern double round(double);
#endif
#endif

#ifndef SCALE_MAX_DISPLAY_MAX_PRECISION
#define SCALE_MAX_DISPLAY_MAX_PRECISION 37 
#endif

class ScaleFuncData {
public:
    ScaleFuncData(double mi, double ma, double st, void (*fn)(void *, void *), gpointer da) {
        min=mi;
        max=ma;
        step=st;
        func=fn;
        data=da;
    }
    ScaleFuncData(double mi, double ma, double st, GCallback fn, gpointer da) {
        min=mi;
        max=ma;
        step=st;
        func=(void (*)(void*, void*))fn;
        data=da;
    }

    double min; 
    double max; 
    double step; 
    void (*func)(void *arg1, void *arg2); 
    gpointer data; 
};
#define SCALESTRUCT(mi,ma,st,fn,da) ScaleFuncData(mi,ma,st,fn,da)

class HScaleFuncData : public ScaleFuncData {
public:
    HScaleFuncData(double mi, double ma, double st) : ScaleFuncData(mi, ma, st, (GCallback)NULL, NULL) {}
    HScaleFuncData(double mi, double ma, double st, void (*fn)(void *, void *),gpointer da) : ScaleFuncData(mi, ma, st, fn, da) {}
    HScaleFuncData(double mi, double ma, double st, GCallback fn, gpointer da) : ScaleFuncData(mi, ma, st, fn, da) {}
};

class VScaleFuncData : public ScaleFuncData {
public:
    VScaleFuncData(double mi, double ma, double st) : ScaleFuncData(mi, ma, st, (GCallback)NULL, NULL) {}
    VScaleFuncData(double mi, double ma, double st, void (*fn)(void *, void *),gpointer da) : ScaleFuncData(mi, ma, st, fn, da) {}
    VScaleFuncData(double mi, double ma, double st, GCallback fn, gpointer da) : ScaleFuncData(mi, ma, st, fn, da) {}
};

class Scales : public LinkList<GtkWidget *> {

    void setDigits(double step) {
        step=fabs(step)-floor(fabs(step))/10.; // find the remainder mod 1.
        int digits=1; // start with no digits
        if (step!=0.) // if the remainder is < 0. then we need more digits.
            while ((step*=10.)<1.) // keep adding digits till we get above 1. and that is the number we need
                digits++;
        if (digits>SCALE_MAX_DISPLAY_MAX_PRECISION) digits=SCALE_MAX_DISPLAY_MAX_PRECISION; // ensure we don't show too much
        gtk_scale_set_digits(GTK_SCALE(current()),digits);
    }

    static void quantiseVal(void *wid, void *data) {
        GtkAdjustment *adj=gtk_range_get_adjustment(GTK_RANGE(wid));
#if GTK_MAJOR_VERSION!=2
            double step_size=gtk_adjustment_get_step_increment(adj);
#else
            double step_size=adj->step_increment;
#endif
        int rounded=(int)round(gtk_range_get_value(GTK_RANGE(wid))/step_size);
        gtk_range_set_value(GTK_RANGE(wid),step_size*(double)rounded);
    }

public:
    virtual ~Scales(void) {
    }

    static double getVal(GtkRange * wid) {
        return gtk_range_get_value(wid);
    }

    double getVal(void) {
        if (getCount())
            return gtk_range_get_value((GtkRange*)current());
                return std::numeric_limits<double>::quiet_NaN();
    }

    double getStep(void) {
        if (getCount()) {
            GtkAdjustment* gtkAdj=gtk_range_get_adjustment(GTK_RANGE(current()));
#if GTK_MAJOR_VERSION!=2
            return gtk_adjustment_get_step_increment(gtkAdj);
#else
            return gtkAdj->step_increment;
#endif
        }
                return std::numeric_limits<double>::quiet_NaN();
    }

    void setStep(double step) {
        if (getCount()) {
            GtkAdjustment* gtkAdj=gtk_range_get_adjustment(GTK_RANGE(current()));
#if GTK_MAJOR_VERSION!=2
            return gtk_adjustment_set_step_increment(gtkAdj, step);
#else
            gtkAdj->step_increment=step;
#endif
                        gtk_range_set_adjustment(GTK_RANGE(current()), gtkAdj);
        }
    }

        void setLower(double lower){
        if (getCount()) {
            GtkAdjustment* gtkAdj=gtk_range_get_adjustment(GTK_RANGE(current()));
#if GTK_MAJOR_VERSION!=2
                         gtk_adjustment_set_lower(gtkAdj, lower);
#else
            gtkAdj->lower=lower;
#endif
                        gtk_range_set_adjustment(GTK_RANGE(current()), gtkAdj);
        }
        }


        void setUpper(double upper){
        if (getCount()) {
            GtkAdjustment* gtkAdj=gtk_range_get_adjustment(GTK_RANGE(current()));
#if GTK_MAJOR_VERSION!=2
                         gtk_adjustment_set_upper(gtkAdj, upper);
#else
            gtkAdj->upper=upper;
#endif
                        gtk_range_set_adjustment(GTK_RANGE(current()), gtkAdj);
        }
        }

        double getLower(void){
        if (getCount()) {
            GtkAdjustment* gtkAdj=gtk_range_get_adjustment(GTK_RANGE(current()));
#if GTK_MAJOR_VERSION!=2
                         return gtk_adjustment_get_lower(gtkAdj);
#else
            return gtkAdj->lower;
#endif
        }
        }

        double getUpper(void){
        if (getCount()) {
            GtkAdjustment* gtkAdj=gtk_range_get_adjustment(GTK_RANGE(current()));
#if GTK_MAJOR_VERSION!=2
                         return gtk_adjustment_get_upper(gtkAdj);
#else
            return gtkAdj->upper;
#endif
        }
        }

    Scales& operator =(double pos) {
        if (getCount())
            gtk_range_set_value((GtkRange*)current(),pos);
        return *this;
    }

    Scales& operator =(int pos) {
        return this->operator=((double)pos);
    }

    Scales &drawValue() {
        if (getCount())
            gtk_scale_set_draw_value((GtkScale*)current(), FALSE);
    }

    Scales &operator<<(HScaleFuncData sf) {
        LinkList<GtkWidget *>::add(gtk_hscale_new_with_range(sf.min,sf.max,sf.step));
        setDigits(sf.step);
        gtk_widget_show(current());
        if (sf.func) //set the callback
            g_signal_connect(G_OBJECT((GtkScale*)current()), "value_changed",reinterpret_cast<GCallback>(sf.func), sf.data);
        return *this;
    }

    Scales &operator<<(VScaleFuncData sf) {
        LinkList<GtkWidget *>::add(gtk_vscale_new_with_range(sf.min,sf.max,sf.step));
        setDigits(sf.step);
        gtk_widget_show(current());
        if (sf.func) //set the callback
            g_signal_connect(G_OBJECT((GtkScale*)current()), "value_changed",reinterpret_cast<GCallback>(sf.func), sf.data);
        return *this;
    }

    int findIndex(GtkWidget* widget) {
        int ret=0;
        if (getCount()) {
            GtkWidget *c=current(); // remember our current location
            grab(1);
            prev(); // we are at the last on the list
            for (int i=1; i<=getCount(); i++) {
                if (next()==widget) {
                    ret=i;
                    break;
                }
            }
            while (next()!=c) ; // return to the original button
        }
        return ret;
    }

    void signalConnectAfter(ScaleFuncData sfd) {
        if (sfd.func)
            g_signal_connect_after(G_OBJECT(current()), "value_changed",reinterpret_cast<GCallback>(sfd.func), sfd.data);
    }

    void signalRemove(ScaleFuncData sfd) {
        if (sfd.func) {
            g_signal_handlers_disconnect_by_func(G_OBJECT(current()), (void*)(sfd.func), sfd.data);
        }
    }


    void quantise(bool isQuantised) {
        if (getCount())
            if (isQuantised)
                g_signal_connect(G_OBJECT(current()), "value_changed",reinterpret_cast<GCallback>(quantiseVal), NULL);
            else
                g_signal_handlers_disconnect_matched(G_OBJECT((GtkButton*)current()), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, reinterpret_cast<gpointer>(quantiseVal), NULL);
    }

    void invert(bool isInverted) {
        if (getCount())
            gtk_range_set_inverted(GTK_RANGE(current()),isInverted);
    }
};

#endif //SCALE_H_