UScale.h

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the LGPL
 *****************************************************************************/

#ifndef USCALE_H
#define USCALE_H

#include <vector>
#include <map>

#include <sigc++/sigc++.h>

#include <gtkmm.h>

#include <plotmm/doubleintmap.h>
#include <plotmm/scalediv.h>

namespace Pango {
    class Layout;
    class FontDescription;
}
    class ScaleLabels : public Gtk::EventBox {
        public:
            ScaleLabels(Gtk::PositionType p);
            virtual ~ScaleLabels();

            Pango::FontDescription *font() { return &font_; }
            void set_labels(int offs, const std::map<int,double> &labels);

            void set_labels_color(Gdk::Color color);
            void set_labels_font(Pango::FontDescription fd);
            void set_enabled(bool b);
            bool enabled() const { return enabled_; }
            Glib::ustring format(double) const;
            int text_width(const Glib::ustring &) const;
            int text_height(const Glib::ustring &) const;
            inline Gtk::PositionType position(){ return position_; };

            inline void set_scaleDiv(const PlotMM::ScaleDiv &Div){ scaleDiv_ = Div;};
            inline void set_scaleMap(const PlotMM::DoubleIntMap &Map){ scaleMap_ = Map;};

        protected:
            virtual void newsize_();
            virtual void requestsize_() {}
            virtual bool on_map_event(GdkEvent *event);

            int offset_;
            int layw_, layh_;
            int range_;
            std::map<int,double> labels_;
            Glib::RefPtr<Pango::Layout> layout_;
            Pango::FontDescription font_;
            Gdk::Color label_color;
            bool is_show;

            PlotMM::ScaleDiv scaleDiv_;
            PlotMM::DoubleIntMap scaleMap_;

        private:
            Gtk::PositionType position_;
            bool enabled_;
    };

    class VScaleLabels : public ScaleLabels {
        public:
            VScaleLabels(Gtk::PositionType p);
            virtual ~VScaleLabels();

        protected:
            virtual bool on_expose_event(GdkEventExpose* event);
            virtual void update_();
            virtual void requestsize_();
    };

    class HScaleLabels : public ScaleLabels {
        public:
            HScaleLabels(Gtk::PositionType p);
            virtual ~HScaleLabels();

            inline void set_curPos(double pos)
            {
                last_pos = cur_pos;
                cur_pos = pos;
            };
            inline void use_real_time(bool state){ use_real_time_flag = state;};

        protected:
            virtual bool on_expose_event(GdkEventExpose* event);
            virtual void update_();
            virtual void requestsize_();
            double cur_pos;
            double last_pos;
            time_t last_time;
            bool use_real_time_flag;
    };



    class Scale : public Gtk::EventBox
    {
        public:
            Scale(Gtk::PositionType p, ScaleLabels *labels= 0);
            virtual ~Scale();

            void set_position(Gtk::PositionType p);
            Gtk::PositionType position() const { return position_; }

            void set_ticklengths(int major, int minor);
            void set_scale_color(Gdk::Color color);
            int major_ticklength() const { return majorTL_; }
            int minor_ticklength() const { return minorTL_; }

            inline ScaleLabels* get_labels(){return labels_;};

            void set_enabled(bool b);
            bool enabled() const { return enabled_; }
            inline void set_max_major(int max){maxMaj = max;};
            inline void set_max_minor(int max){maxMin = max;};

            const PlotMM::DoubleIntMap &scale_map() const { return scaleMap_; }

            void set_range(double l, double r);
            void set_range(double l, double r, bool lg);

            void set_autoscale(bool b);
            bool autoscale() const { return autoscale_; }
            void begin_autoscale();
            void autoscale(double min, double max);
            void end_autoscale();

            sigc::signal1<void,bool> signal_enabled;

        protected:
            virtual void on_realize();
            virtual bool on_expose_event(GdkEventExpose* event);
            virtual bool on_map_event(GdkEvent *event);

            virtual void on_tick_change() {}
            virtual void redraw() = 0;

            Glib::RefPtr<Gdk::Window> window_;
            ScaleLabels *labels_;
            Gdk::Color scale_color;
            int maxMaj;
            int maxMin;
            bool is_show;

            PlotMM::ScaleDiv scaleDiv_;
            PlotMM::DoubleIntMap scaleMap_;

        private:
            Gtk::PositionType position_;
            bool autoscale_;
            bool enabled_;
            int majorTL_, minorTL_;
            double asMin_, asMax_;
    };

    class VScale : public Scale
    {
        public:
            VScale(Gtk::PositionType p, ScaleLabels *l= 0);
            virtual ~VScale();

        protected:
            virtual void redraw();
            virtual void on_tick_change();
    };

    class HScale : public Scale
    {
        public:
            HScale(Gtk::PositionType p, ScaleLabels *l= 0);
            virtual ~HScale();

        protected:
            virtual void redraw();
            virtual void on_tick_change();
    };

    class Web : public Gtk::EventBox
    {
        public:
            Web();
            virtual ~Web();

            void set_web_color(Gdk::Color color);

            void set_enabled(bool b);
            bool enabled() const { return enabled_; }
            inline void set_max_h_major(int max){maxMajH = max;};
            inline void set_max_h_minor(int max){maxMinH = max;};
            inline void set_max_v_major(int max){maxMajV = max;};
            inline void set_max_v_minor(int max){maxMinV = max;};

            const PlotMM::DoubleIntMap &h_map() const { return HMap_; }
            const PlotMM::DoubleIntMap &v_map() const { return VMap_; }

            void set_h_range(double l, double r);
            void set_h_range(double l, double r, bool lg);
            void set_v_range(double l, double r);
            void set_v_range(double l, double r, bool lg);

            sigc::signal1<void,bool> signal_enabled;

        protected:
            virtual void on_realize();
            virtual bool on_expose_event(GdkEventExpose* event);
            virtual bool on_map_event(GdkEvent *event);

            virtual void redraw();

            Gdk::Color web_color;
            int maxMajH;
            int maxMinH;
            int maxMajV;
            int maxMinV;
            bool is_show;

            Glib::RefPtr<Gdk::Window> window_;

            PlotMM::ScaleDiv HDiv_;
            PlotMM::DoubleIntMap HMap_;
            PlotMM::ScaleDiv VDiv_;
            PlotMM::DoubleIntMap VMap_;

        private:
            bool enabled_;
    };

#endif