Stable version of notification filter

insitu_plugins/CMakeLists.txt

@@ -62,6 +62,8 @@ set(insitu_plugins_HDRS
     inc/Stats/Stats.hpp
 
     inc/Heartbeat/Heartbeat.hpp
+
+    inc/Notification/Notification.hpp
 )
 
 set(insitu_dialogs_HDRS
@@ -74,6 +76,8 @@ set(insitu_dialogs_HDRS
     inc/Stats/Stats_dialog.hpp
 
     inc/Heartbeat/Heartbeat_dialog.hpp
+
+    inc/Notification/Notification_dialog.hpp
 )
 
 qt5_wrap_cpp(insitu_dialogs_MOCS ${insitu_dialogs_HDRS})
@@ -95,6 +99,11 @@ add_library(${PROJECT_NAME}
     src/Stats/Stats.cpp
     src/Stats/Stats_dialog.cpp
 
+    src/Heartbeat/Heartbeat.cpp
+    src/Heartbeat/Heartbeat_dialog.cpp
+
+    src/Notification/Notification.cpp
+    src/Notification/Notification_dialog.cpp
 )
 
 target_link_libraries(${PROJECT_NAME} 

insitu_plugins/README.md

@@ -16,11 +16,13 @@ filter developers.
     - a circle that turns red if a topic of interest stops publishing
 5. Stats
     - displays CPU, memory, and disk usage
+6. Notification
+    - display scrolling notification messages
 
 ## TODO:
 
 1. Notifications
-    - A scrolling notification window with different alert levels
+    - Add different alert levels
 2. Compass
     - Directional indicator for robots with GPS/Magnetometer capabilites
 3. Movement Lines

insitu_plugins/inc/Notification/Notification.hpp

@@ -0,0 +1,61 @@
+#ifndef insitu_plugins_Notification_HPP
+#define insitu_plugins_Notification_HPP
+
+#include <pluginlib/class_list_macros.h>
+#include <insitu/filter.hpp>
+#include <ros/ros.h>
+#include "std_msgs/String.h"
+#include <queue>
+
+namespace insitu_plugins
+{
+class Notification : public insitu::Filter
+{
+public:
+    Notification(void);
+
+    const cv::Mat apply(void);
+
+    bool hasSettingEditor(void) const
+    {
+        return true;
+    }
+
+    void onTopicChange(const std::string& new_topic);
+
+    void onQueueChange(const int new_queue_size);
+
+    void onDirectionChange(const bool new_msg_direction_down);
+
+private:
+    void filterInit(void);
+
+    void onDelete(void);
+
+    void handleCallback(const std_msgs::String::ConstPtr& msg);
+
+    std::string queueToString(std::queue<std::string> str_queue);
+
+    std::queue<std::string> reverseQueue(std::queue<std::string> str_queue);
+
+    ros::NodeHandle nh_;
+
+    std::string topic_name_;
+
+    ros::Subscriber topic_subscriber_;
+
+    cv::Mat ret_;
+
+    unsigned int queue_size_;
+
+    bool msg_direction_down_;
+
+    std::queue<std::string> msg_queue_;
+
+    std::string msg_string_;
+
+};    // end class Notification
+
+}    // end namespace insitu_plugins
+
+#endif    // end insitu_plugins_Notification_HPP

insitu_plugins/inc/Notification/Notification_dialog.hpp

@@ -0,0 +1,43 @@
+#ifndef insitu_plugins_Notification_DIALOG_HPP
+#define insitu_plugins_Notification_DIALOG_HPP
+
+#include <insitu/filter.hpp>
+
+namespace notification_filter
+{
+const std::string DEFAULT_NAME = "Notification";
+const std::string DEFAULT_TOPIC = "notification_topic";
+const unsigned int DEFAULT_QUEUE_SIZE = 10;
+}    // end namespace notification_filter
+
+namespace insitu_plugins
+{
+class NotificationDialog : public insitu::FilterDialog
+{
+    Q_OBJECT
+private:
+    QGridLayout* layout;
+    QErrorMessage* error_msg;
+
+    QLineEdit* nameEdit;
+    QLabel* nameLabel;
+    QLineEdit* topicEdit;
+    QLabel* topicLabel;
+    QDoubleSpinBox* queueBox;
+    QLabel* queueLabel;
+    QCheckBox* dirBox;
+
+    QPushButton* okButton;
+    QPushButton* cancelButton;
+
+public Q_SLOTS:
+
+    void onOK(void);
+
+public:
+    NotificationDialog(insitu::Filter* parent_);
+};
+
+}    // end namespace insitu_plugins
+
+#endif    // end insitu_plugins_Notification_DIALOG_HPP

insitu_plugins/plugins.xml

@@ -8,13 +8,13 @@
   <class type="insitu_plugins::Transparent" base_class_type="insitu::Filter">
     <description>testing new transparency filters</description>
   </class>
-  <class type="insitu_plugins::Notify" base_class_type="insitu::Filter">
-    <description>display scrolling notifications</description>
-  </class>
   <class type="insitu_plugins::Stats" base_class_type="insitu::Filter">
     <description>basic computer statistics</description>
   </class>
   <class type="insitu_plugins::Heartbeat" base_class_type="insitu::Filter">
     <description>Check to see if a topic is published</description>
   </class>
+  <class type="insitu_plugins::Notification" base_class_type="insitu::Filter">
+    <description>Display scrolling notification messages</description>
+  </class>
 </library>

insitu_plugins/src/Notification/Notification.cpp

@@ -0,0 +1,199 @@
+#include <Notification/Notification.hpp>
+#include <Notification/Notification_dialog.hpp>
+#include <insitu_utils/painter.hpp>
+
+using namespace notification_filter;
+
+namespace insitu_plugins
+{
+/*
+    Filter Implementation
+*/
+
+Notification::Notification(void)
+{
+    // TODO instantiation code
+}
+
+void Notification::filterInit(void)
+{
+    settingsDialog = new NotificationDialog(this);
+    setSize(QSize(300, 300));
+
+    nh_ = getNodeHandle();
+
+    topic_name_ = getSettingsValue().get("topic", DEFAULT_TOPIC).asString();
+
+    topic_subscriber_ =    // 2nd parameter is queue size
+        nh_.subscribe(topic_name_, 1, &Notification::handleCallback, this);
+
+    queue_size_ =
+        getSettingsValue().get("queue_size", DEFAULT_QUEUE_SIZE).asInt();
+
+    msg_direction_down_ =
+        getSettingsValue().get("msg_direction_down", true).asBool();
+
+    msg_string_ = queueToString(msg_queue_);
+
+    // TODO ROS initialization code
+}
+
+void Notification::onDelete(void)
+{
+    topic_subscriber_.shutdown();
+}
+
+const cv::Mat Notification::apply(void)
+{
+    /*
+        Create a transparent image to construct your overlay on
+    */
+    ret_ = cv::Mat(height(), width(), CV_8UC4, cv::Scalar(255, 255, 255, 0));
+
+    insitu_utils::Painter::drawtorect_multiline(
+        ret_, cv::Rect(0, 0, ret_.cols, ret_.rows), msg_string_,
+        queue_size_ + 2);
+
+    return ret_;
+}
+
+void Notification::handleCallback(const std_msgs::String::ConstPtr& msg)
+{
+    /*
+        Update queue with the most recent messages
+    */
+    if (msg_queue_.size() >= queue_size_)
+    {
+        msg_queue_.pop();
+    }
+    msg_queue_.push(msg->data);
+    msg_string_ = queueToString(msg_queue_);
+}
+
+std::string Notification::queueToString(std::queue<std::string> str_queue)
+{
+    std::queue<std::string> q = str_queue;
+    std::string str;
+    int topic_name_len = std::round(topic_name_.length() *
+                                    0.67);    // 0.7 makes the the widths match
+
+    /*
+        Add topic name and divider
+    */
+    str += topic_name_ + "\n";
+    for (int i = 0; i < topic_name_len; i++)
+    {
+        str += "-";
+    }
+    str += "\n";
+
+    /*
+        Check new message direction
+    */
+    if (!msg_direction_down_)
+    {
+        q = reverseQueue(q);
+    }
+
+    /*
+        Add queue messages
+    */
+    while (!q.empty())
+    {
+        str += q.front() + "\n";
+        q.pop();
+    }
+
+    return str;
+}
+
+std::queue<std::string>
+Notification::reverseQueue(std::queue<std::string> str_queue)
+{
+    std::queue<std::string> q = str_queue;
+    std::stack<std::string> s;
+
+    /*
+        Fill stack
+    */
+    while (!q.empty())
+    {
+        s.push(q.front());
+        q.pop();
+    }
+
+    /*
+        Fill queue
+    */
+    while (!s.empty())
+    {
+        q.push(s.top());
+        s.pop();
+    }
+
+    return q;
+}
+
+void Notification::onTopicChange(const std::string& new_topic)
+{
+    if (topic_name_ != new_topic)
+    {
+        /*
+            Update topic name
+        */
+        try
+        {
+            topic_name_ = new_topic;
+            topic_subscriber_ =    // 2nd parameter is queue size
+                nh_.subscribe(topic_name_, 1, &Notification::handleCallback,
+                              this);
+        }
+        catch (ros::Exception& e)
+        {
+            ROS_ERROR("Error occured: %s ", e.what());
+        }
+
+        /*
+            Clear queue
+        */
+        std::queue<std::string>().swap(msg_queue_);
+        msg_string_ = queueToString(msg_queue_);
+    }
+}
+
+void Notification::onQueueChange(const int new_queue_size)
+{
+    if (queue_size_ != new_queue_size)
+    {
+        /*
+            Update queue size
+        */
+        queue_size_ = new_queue_size;
+
+        /*
+            Clear queue
+        */
+        std::queue<std::string>().swap(msg_queue_);
+        msg_string_ = queueToString(msg_queue_);
+    }
+}
+
+void Notification::onDirectionChange(const bool new_msg_direction_down)
+{
+    if (msg_direction_down_ != new_msg_direction_down)
+    {
+        /*
+            Update new message direction
+        */
+        msg_direction_down_ = new_msg_direction_down;
+
+        /*
+            Update string
+        */
+        msg_string_ = queueToString(msg_queue_);
+    }
+}
+
+}    // end namespace insitu_plugins
+
+PLUGINLIB_EXPORT_CLASS(insitu_plugins::Notification, insitu::Filter);