dot_matrix_display.h

Go to the documentation of this file.

#pragma once
#include <array>
#include <xtd/argument_out_of_range_exception.h>
#include <xtd/drawing/solid_brush.h>
#include "control.h"
#include "segments.h"
#include "dot_matrix_style.h"
 
namespace xtd {
  namespace forms {
    class dot_matrix_display : public control {
    public:
      using dots_collection =  std::vector<std::vector<bool>>;
      
      using points_collection =  std::vector<xtd::drawing::point>;
      
      dot_matrix_display() {
        auto_size(true);
        double_buffered(true);
        size_ = default_size();
      }
 
      virtual drawing::color back_dot_color() {return back_dot_color_.value_or(fore_color());}
      virtual dot_matrix_display& back_dot_color(const drawing::color& value) {
        if (!back_dot_color_.has_value() || back_dot_color_.value() != value) {
          back_dot_color_ = value;
          invalidate();
        }
        return *this;
      }
 
      virtual double back_dot_opacity() const {return back_dot_opacity_;}
      virtual dot_matrix_display& back_dot_opacity(double value) {
        if (value < 0.0 || value > 1.0) throw argument_out_of_range_exception("value must be between 0.0 and 1.0."_t, current_stack_frame_);
        if (back_dot_opacity_ != value) {
          back_dot_opacity_ = value;
          if (back_dot_opacity_ < 0.0) back_dot_opacity_ = 0.0;
          if (back_dot_opacity_ > 1.0) back_dot_opacity_ = 1.0;
          invalidate();
        }
        return *this;
      }
 
      virtual forms::dot_matrix_style dot_matrix_style() const {return dot_matrix_style_;}
      virtual dot_matrix_display& dot_matrix_style(forms::dot_matrix_style value) {
        if (dot_matrix_style_ != value) {
          dot_matrix_style_ = value;
          invalidate();
        }
        return *this;
      }
 
      virtual const dots_collection& dots() const {return dots_;}
      virtual const dot_matrix_display& dots(const dots_collection& dots) {
        if (dots_ != dots) {
          dots_ = dots;
          matrix_size_ = drawing::size(static_cast<int32_t>(dots_[0].size()), static_cast<int32_t>(dots_.size()));
          invalidate();
        }
        return *this;
      }
 
      virtual int32_t matrix_height() const {return matrix_size_.height();}
      virtual void matrix_height(int32_t value) {matrix_size({matrix_size_.width(), value});}
      
      virtual int32_t matrix_width() const {return matrix_size_.width();}
      virtual void matrix_width(int32_t value) {matrix_size({value, matrix_size_.height()});}
      
      virtual const drawing::size& matrix_size() const {return matrix_size_;}
      virtual void matrix_size(const drawing::size& value) {
        if (matrix_size_ != value) {
          matrix_size_ = value;
          dots_ = dots_collection(matrix_size_.height(), std::vector<bool>(matrix_size_.width(), false));
          invalidate();
        }
      }
 
      virtual bool show_back_dot() const {return show_back_dot_;}
      virtual dot_matrix_display& show_back_dot(bool value) {
        if (show_back_dot_ != value) {
          show_back_dot_ = value;
          invalidate();
        }
        return *this;
      }
 
      virtual int32_t thickness() const {return thickness_.value_or(size_.height() < (matrix_size_.height() * 2) ? 1 : (size_.height() - matrix_size_.height()) / matrix_size_.height());}
      virtual dot_matrix_display& thickness(int32_t value) {
        if (!thickness_.has_value() || thickness_.value() != value) {
          thickness_ = value;
          invalidate();
        }
        return *this;
      }
 
      virtual void set_all_dots(bool on) {
        for (int32_t y = 0; y < static_cast<int32_t>(dots_.size()); y++)
          for (int32_t x = 0; x < static_cast<int32_t>(dots_[y].size()); x++)
            dots_[y][x] = on;
      }
      
      virtual bool get_dot(const drawing::point& point) const {return dots_[point.y()][point.x()];}
      
      virtual void set_dot(const drawing::point& point, bool on) {
        if (dots_[point.y()][point.x()] != on) {
          dots_[point.y()][point.x()] = on;
          invalidate();
        }
      }
 
      virtual void set_dots(const points_collection& points) {
        set_all_dots(false);
        set_dots(points, true);
      }
      virtual void set_dots(const points_collection& points, bool on) {
        for (auto point : points)
          set_dot(point, on);
      }
 
    protected:
      drawing::size default_size() const override {return {25, 25};}
      
      void on_back_color_changed(const event_args& e) override {
        control::on_back_color_changed(e);
        invalidate();
      }
      
      void on_fore_color_changed(const event_args& e) override {
        control::on_fore_color_changed(e);
        invalidate();
      }
 
      void on_paint(paint_event_args& e) override {
        if (back_color() != default_back_color()) e.graphics().clear(back_color());
        for (int32_t y = 0; y < static_cast<int32_t>(dots_.size()); y++) {
          for (int32_t x = 0; x < static_cast<int32_t>(dots_[y].size()); x++) {
            if (dots_[y][x]) draw_dot(e.graphics(), fore_color(), {x, y});
            else if (show_back_dot_) draw_dot(e.graphics(), drawing::color::average(back_dot_color(), back_color(), back_dot_opacity_), {x, y});
          }
        }
        control::on_paint(e);
      }
      
      drawing::size measure_control() const override {
        int32_t width = static_cast<int32_t>(static_cast<double>(height()) / matrix_height() * matrix_width());
        return drawing::size(width, height());
      }
 
      virtual void draw_dot(drawing::graphics& graphics, const drawing::color& color, const drawing::point& point) {
        int32_t y = (height() - static_cast<int32_t>(dots_.size())) / static_cast<int32_t>(dots_.size());
        int32_t x = (width() - static_cast<int32_t>(dots_[point.y()].size()))  / static_cast<int32_t>(dots_[point.y()].size());
        if (dot_matrix_style_ == dot_matrix_style::standard)
          graphics.fill_pie(drawing::solid_brush(color), (1 + x) * point.x(), (1 + y) * point.y(), thickness(), thickness(), 0, 360);
        else if (dot_matrix_style_ == dot_matrix_style::square)
          graphics.fill_rectangle(drawing::solid_brush(color), (1 + x) * point.x(), (1 + y) * point.y(), thickness(), thickness());
      }
 
      drawing::size matrix_size_ = {7, 7};
      dots_collection dots_ = dots_collection(matrix_size_.width(), std::vector<bool>(matrix_size_.height(), false));
      bool show_back_dot_ = true;
      std::optional<drawing::color> back_dot_color_;
      double back_dot_opacity_ = 0.95;
      forms::dot_matrix_style dot_matrix_style_ = forms::dot_matrix_style::standard;
      std::optional<int32_t> thickness_;
    };
  }
}