ui_base.H

Go to the documentation of this file.

// Copyright (C) 2005-2009 Christopher Mire
// Copyright (C) 2005-2009 University of Louisiana at Lafayette

#ifndef CAJUN_CBSTAT_UI_BASE_H
#define CAJUN_CBSTAT_UI_BASE_H

#include "queue_generator.H"
#include "util.H"
#include "cb_time.H"
#include "conf.H"
#include <gtk/gtk.h>
#include <cstring>

namespace cajun
{
        enum { VALID, QUEUE_TITLE, FREQ, DATA, VIEW, N_COLUMNS };

        class my_ui_base_t
        {
        public:
                my_ui_base_t (const gchar *name_);
                virtual ~my_ui_base_t () {}

                void init ();
                void update_ui ();

                virtual const unsigned num_fields () const = 0;
                virtual const std::string get_queue_member (const unsigned FIELD_) const = 0;
                virtual const std::string get_queue_member_value (const unsigned FIELD_) const = 0;
                virtual gboolean new_data () = 0;
                const std::string get_class_name () const {return std::string (name);};

                void set_tree_store (GtkTreeStore *store_)
                        { m_store = store_; }
                void set_parent_iter (GtkTreeIter iter)
                        { m_parent_iter = iter; }
                void set_child_iter (GtkTreeIter iter)
                        { m_queue_iters.push_back (iter); }

        protected:
                virtual double read_data () = 0;

                GdkPixbuf *m_pixbuf_yellow;
                GdkPixbuf *m_pixbuf_active;
                GdkPixbuf *m_pixbuf_deactive;

                GtkTreeStore *m_store;
                GtkTreeIter m_parent_iter;
                std::vector<GtkTreeIter> m_queue_iters;

                gdouble time_interval;
                const gchar *name;
                gdouble tstamp;
                gdouble data_record1;
                gdouble data_record2;
                gdouble latest_tstamp;
        };

        template <typename T>
        class my_ui_t : public my_ui_base_t
        {
        public:
                my_ui_t (const gchar *name) : my_ui_base_t (name)
                        {
                                m_reader = get_queue_reader (&data_t);
                        }
                virtual ~my_ui_t () { delete m_reader; }

                void update_ui ();

                const unsigned num_fields () const;
                const std::string get_queue_member (const unsigned FIELD_) const;
                const std::string get_queue_member_value (const unsigned FIELD_) const;

                gboolean new_data ()
                        {
                                if (m_reader->at_head ())
                                        return false;
                                else
                                {
                                        m_reader->next (data_t);
                                        return true;
                                }
                        }

        protected:
                double read_data ();
                T data_t;
                data_queue_reader_t<T>  *m_reader;
        };

        template <typename T>
        double my_ui_t<T>::read_data ()
        {
                if (! m_reader->initialized ())
                        return -1;

                // save old data , used for determining frequency
                data_record2 = data_record1;

                if (strncmp (name, "cbmesg", sizeof (name)) != 0)
                {
                        if (! m_reader->at_head ())
                                latest_tstamp = cb_time_t::curr_time ();
                        data_record1 = m_reader->head (data_t);
                }
                else//dont want to skip date from cbmesg
                {
                        if (! m_reader->at_head ())
                        {
                                data_record1 = m_reader->next (data_t);
                                latest_tstamp = cb_time_t::curr_time ();
                        }

                }

                gdouble new_time = cb_time_t::curr_time ();

                return (data_record1 - data_record2) / (new_time - tstamp);
        }
};


#endif

---