Changeset 208

Timestamp:

17/08/09 20:42:41 (4 years ago)

Author:

guyru

Message:

Render legend in the SimplePiePlot? widget

Location:

trunk/src

Files:

• simple_pie_plot.cpp (modified) (8 diffs)
• simple_pie_plot.h (modified) (2 diffs)
• statistics_dialog.cpp (modified) (3 diffs)
• statistics_dialog.h (modified) (1 diff)

trunk/src/simple_pie_plot.cpp

@@ -22 +22 @@
 #include <boost/foreach.hpp>
 #include <memory>
+#include <algorithm>
 #include <cmath>
 using namespace std;
@@ -59 +60 @@
 {
         m_highlight = -1;
+
+        m_max_legend_width = 0;
+        m_max_legend_height = 0;
+        m_legend_width = 0;
+
         Connect(this->GetId(), wxEVT_PAINT, wxPaintEventHandler(SimplePiePlot::OnPaint));
         Connect(this->GetId(), wxEVT_SIZE, wxSizeEventHandler(SimplePiePlot::OnResize));
@@ -71 +77 @@
         auto_ptr<wxGraphicsContext> dc(wxGraphicsContext::Create(pdc));
         wxBrush color_brush;
-        int width, height;
-
-        GetClientSize(&width, &height);
-
-        // radius should be set so it fits exactly
-        double radius = (width>height? height : width)/2.0;
-
+
+        if (!m_max_legend_width || !m_max_legend_height) {
+                CalculateLegendDimensions(dc.get());
+                // This might have caused a new minimum size to occure, tell
+                // parent about it by refitting. See also comment in
+                // GetMinSize()
+                if (this->GetParent() && this->GetParent()->GetSizer())
+                        this->GetParent()->GetSizer()->SetSizeHints(this->GetParent());
+        }
+        CalculatePiePlotLocation();
+        
+
+        dc->SetPen(*wxTRANSPARENT_PEN);
         for (int i = 1; i<m_angles.size(); i++) {
                 // create brush
@@ -83 +95 @@
                 dc->SetBrush(color_brush);
 
-                DrawPieSlice(width/2.0, height/2.0, radius, m_angles[i-1],
+                DrawPieSlice(m_pie_x, m_pie_y, m_radius, m_angles[i-1],
                              m_angles[i], dc.get());
         }
+
+        DrawLegend(dc.get());
+}
+
+void SimplePiePlot::CalculatePiePlotLocation()
+{
+        double pie_width;
+        int width, height;
+
+        assert(m_legend_width);
+
+        GetClientSize(&width, &height);
+        // m_max_legend_height* for the color box and it's right padding
+        pie_width = width - m_legend_width - m_legend_left_padding;
+        m_pie_x = pie_width/2.0;
+        m_pie_y = height/2.0;
+        m_radius = min(pie_width,(double)height)/2.0;
 }
 
@@ -94 +123 @@
 }
 
-void SimplePiePlot::SetData(vector<double> d)
-{
+void SimplePiePlot::SetData(vector<double> d, vector<wxString> labels)
+{
+        // number of values should match number of labels
+        assert(labels.size() == d.size());
+
         m_data.clear();
         m_data_total = 0;
         BOOST_FOREACH(double tmp, d) {
+                // we can't plot negative values
+                assert(tmp >= 0);
                 m_data_total += tmp;
-                if (tmp!=0)
-                        m_data.push_back(tmp);
-        }
+                m_data.push_back(tmp);
+        }
+        m_labels.assign(labels.begin(), labels.end());
+        CalculateAngles();
+
+        // this will cause the legend size to be re-calculated
+        m_max_legend_width = 0;
+        m_max_legend_height = 0;
+}
+
+void SimplePiePlot::CalculateAngles()
+{
+        double new_angle = 0;
 
         m_angles.clear();
-        double new_angle = 0;
         m_angles.push_back(new_angle);
         BOOST_FOREACH(double tmp, m_data) {
@@ -113 +156 @@
 }
 
+void SimplePiePlot::CalculateLegendDimensions(wxGraphicsContext *dc)
+{
+        double tmp_height;
+        double tmp_width;
+        m_max_legend_width = 0;
+        m_max_legend_height = 0;
+
+        dc->SetFont(*wxNORMAL_FONT, *wxBLACK);
+        
+        BOOST_FOREACH(wxString label, m_labels) {
+                dc->GetTextExtent(label, &tmp_width, &tmp_height, NULL, NULL);
+                m_max_legend_width = max(m_max_legend_width, tmp_width);
+                m_max_legend_height = max(m_max_legend_height, tmp_height);
+        }
+
+        m_legend_width = m_max_legend_width + 2*m_max_legend_height;
+        m_legend_line_height = 1.5 * m_max_legend_height;
+}
+
+void SimplePiePlot::DrawLegend(wxGraphicsContext *dc)
+{
+        wxBrush color_brush;
+        int width, height;
+        GetClientSize(&width, &height);
+
+        assert(m_legend_width);
+        double legend_x = width - m_legend_width;
+
+        dc->SetPen(*wxTRANSPARENT_PEN);
+        dc->SetFont(*wxNORMAL_FONT, *wxBLACK);
+
+        for (int i = 0; i<m_labels.size(); i++) {
+                color_brush.SetColour(GetSegmentColor(i));
+                dc->SetBrush(color_brush);
+
+                dc->DrawRectangle(legend_x, i * m_legend_line_height,
+                        m_max_legend_height, m_max_legend_height);
+                dc->DrawText(m_labels[i], legend_x + 2*m_max_legend_height,
+                        i * m_legend_line_height);
+        }
+
+}
+
 wxColour SimplePiePlot::GetSegmentColor(int i)
 {
         double hue_step = 1.0/(m_data.size());
         double hue = i * hue_step;
-        double value = m_highlight == i ? 1.0 : 0.8;
+        double value = m_highlight == i ? 1.0 : 0.9;
         wxColour color;
         wxImage::RGBValue rgb;
@@ -132 +218 @@
         int width, height;
         GetClientSize(&width, &height);
-        // radius should be set so it fits exactly
-        const double radius = (width>height? height : width)/2.0;
-
-        const double dist_mouse = (width/2.0-event.m_x)*(width/2.0-event.m_x) + 
-                            (height/2.0-event.m_y)*(height/2.0-event.m_y);
-        if (dist_mouse > (radius*radius)) { 
-                ClearHighlight();
+
+        const double dist_mouse = (m_pie_x-event.m_x)*(m_pie_x-event.m_x) + 
+                            (m_pie_y-event.m_y)*(m_pie_y-event.m_y);
+        if (dist_mouse <= (m_radius*m_radius)) { 
+                //angles are clockwise from the x-axis
+                double angle = acos((event.m_x-m_pie_x)/sqrt(dist_mouse));
+                if (event.m_y < m_pie_y)
+                        angle = 2*PI - angle;
+                int i;
+                for (i = 1; i<m_angles.size(); i++) {
+                        if (angle<=m_angles[i])
+                                break;
+                }
+                Highlight(i-1);
                 return;
-        }
-
-        //angles are clockwise from the x-axis
-        double angle = acos((event.m_x-width/2.0)/sqrt(dist_mouse));
-        if (event.m_y < height/2.0)
-                angle = 2*PI - angle;
-        int i;
-        for (i = 1; i<m_angles.size(); i++) {
-                if (angle<=m_angles[i])
-                        break;
-        }
-        Highlight(i-1);
+        } else if (event.m_x >= width-m_legend_width){
+                int i = (int) (event.m_y / m_legend_line_height);
+                if (i<m_labels.size()){
+                        Highlight(i);
+                        return;
+                }
+        }
+
+        ClearHighlight();
 }
 
@@ -172 +262 @@
         }
 }
+
+wxSize SimplePiePlot::GetMinSize() const
+{
+        // In the first call to GetMinSize, m_legend_line_height and
+        // m_legend_width may not be populated yet (set to zero), this
+        // is a result of not being able to call CalculateLegendDimensions()
+        // at this point due to constness. In order to workaround this issue,
+        // if CalculateLegendDimensions() gets called in OnPaint() (this
+        // happens also after setting new data), OnPaint() also notifies the
+        // parent's sizer (is such exist) to update the size hints
+        // accordingly.
+        const double total_legend_height = m_labels.size() * m_legend_line_height;
+        const double total_width = total_legend_height + m_legend_width +
+                                   m_legend_left_padding;
+        return wxSize((int)ceil(total_width),(int)ceil(total_legend_height));
+}
+

trunk/src/simple_pie_plot.h

@@ -32 +32 @@
                  const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
                  long style = wxNO_BORDER, const wxString& name = wxPanelNameStr);
-        void SetData(std::vector<double> d);
+        void SetData(std::vector<double> d, std::vector<wxString> labels);
         void OnPaint(wxPaintEvent& event);
         void OnResize(wxSizeEvent& event);
         void OnMouseLeaveWindow(wxMouseEvent& event);
         void OnMouseMove(wxMouseEvent& event);
+        wxSize GetMinSize() const;
 private:
         /**
@@ -44 +45 @@
         wxColour GetSegmentColor(int i);
 
+        /**
+         * Calculate the angles in the plot and populate the m_angles array.
+         */
+        void CalculateAngles();
+
+        /**
+         * Calculate the maximum widht and height for a label in the legend.
+         */
+        void CalculateLegendDimensions(wxGraphicsContext *dc);
+
+        /**
+         * Calculate the location and radius of the pie plot.
+         */
+        void CalculatePiePlotLocation();
+
+        void DrawLegend(wxGraphicsContext *dc);
+
         void Highlight(int i);
         void ClearHighlight();
 
         std::vector<double> m_data;
+        std::vector<wxString> m_labels;
         std::vector<double> m_angles;
         double m_data_total;
         int m_highlight;
+
+        /// maximum width for a label in the legend.
+        double m_max_legend_width;
+        /// maximum height for a label in the legend.
+        double m_max_legend_height;
+        /// total width of the legend
+        double m_legend_width;
+        /// the line height of each legend entry including padding
+        double m_legend_line_height;
+
+        static const double m_legend_left_padding = 10;
+
+        // The center point of the pie plot
+        double m_pie_x;
+        double m_pie_y;
+        double m_radius;
+
 };
 

trunk/src/statistics_dialog.cpp

@@ -46 +46 @@
         games_started = new wxStaticText(this, wxID_ANY, wxT(""));
         games_finished = new wxStaticText(this, wxID_ANY, wxT(""));
-        histogram = new simple_pie_plot::SimplePiePlot(this, wxID_ANY);
+        pie_plot = new simple_pie_plot::SimplePiePlot(this, wxID_ANY);
         statistics_reset_date = new wxStaticText(this, wxID_ANY, wxT(""));
 }
@@ -64 +64 @@
 
         vector<int> score_dist = m_stats->score_distribution();
-        vector<double> dist (score_dist.begin(), score_dist.end());
-        histogram->SetData(dist);
+        vector<double> dist;
+        vector<wxString> labels;
+        for (int i; i<score_dist.size(); i++) {
+                if (score_dist[i]) {
+                        assert(score_dist[i]>0);
+                        dist.push_back(score_dist[i]);
+                        tmp = wxString::Format(wxT("%i - %i"),
+                                i*statistics::score_distribution_granuality,
+                                (i+1)*statistics::score_distribution_granuality);
+                        labels.push_back(tmp);
+                }
+        }
+        pie_plot->SetData(dist, labels);
 }
 
@@ -79 +90 @@
 
         wxStaticBoxSizer* score_distribution = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxT("Score Distribution") ), wxHORIZONTAL);
-        score_distribution->Add(histogram, 1, wxEXPAND, 10);
+        score_distribution->Add(pie_plot, 1, wxEXPAND, 10);
         top_sizer->Add(score_distribution,10,wxEXPAND, 10);
 

trunk/src/statistics_dialog.h

@@ -47 +47 @@
         wxStaticText *games_finished;
         wxStaticText *statistics_reset_date;
-        simple_pie_plot::SimplePiePlot* histogram;
+        simple_pie_plot::SimplePiePlot* pie_plot;
 
         statistics::Statistics* m_stats;