font.h

Go to the documentation of this file.

 
#pragma once
#include <cstdint>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <vector>
#include <xtd/object.h>
#include <xtd/ustring.h>
#include "../drawing_export.h"
#include "font_family.h"
#include "graphics_unit.h"
 
namespace xtd {
  namespace forms {
    namespace native {
      class font_dialog;
    }
  }
  
  namespace drawing {
    class graphics;
    class system_fonts;
    
    class drawing_export_ font final : public object {
    public:
      font (const font& prototype, float em_size);
      
      font (const font& prototype, float em_size, font_style style);
      
      font (const font& prototype, font_style style);
      
      font(xtd::ustring family_name, float em_size, font_style style, graphics_unit unit, uint8_t gdi_char_set, bool gdi_vertical_font);
      
      font(const drawing::font_family& font_family, float em_size, font_style style, graphics_unit unit, uint8_t gdi_char_set, bool gdi_vertical_font) : font(font_family.name(), em_size, style, unit, gdi_char_set, gdi_vertical_font) {}
      
      font(xtd::ustring family_name, float em_size, font_style style, graphics_unit unit, uint8_t gdi_char_set) : font(family_name, em_size, style, unit, gdi_char_set, false) {}
      
      font(const drawing::font_family& font_family, float em_size, font_style style, graphics_unit unit, uint8_t gdi_char_set) : font(font_family, em_size, style, unit, gdi_char_set, false) {}
      
      font(xtd::ustring family_name, float em_size, font_style style, graphics_unit unit) : font(family_name, em_size, style, unit, 0, false) {}
      
      font(const drawing::font_family& font_family, float em_size, font_style style, graphics_unit unit) : font(font_family, em_size, style, unit, 0, false) {}
      
      font(xtd::ustring family_name, float em_size, font_style style) : font(family_name, em_size, style, graphics_unit::point, 0, false) {}
      
      font(const drawing::font_family& font_family, float em_size, font_style style) : font(font_family, em_size, style, graphics_unit::point, 0, false) {}
      
      font(xtd::ustring family_name, float em_size, graphics_unit unit) : font(family_name, em_size, font_style::regular, unit, 0, false) {}
      
      font(const drawing::font_family& font_family, float em_size, graphics_unit unit) : font(font_family, em_size, font_style::regular, unit, 0, false) {}
 
      font(xtd::ustring family_name, float em_size) : font(family_name, em_size, font_style::regular, graphics_unit::point, 0, false) {}
      
      font(const drawing::font_family& font_family, float em_size) : font(font_family, em_size, font_style::regular, graphics_unit::point, 0, false) {}
 
      font(const font& value);
      font& operator=(const font& value);
      bool operator==(const font& value) const {return data_->font_family_ == value.data_->font_family_ && data_->gdi_char_set_ == value.data_->gdi_char_set_ && data_->gdi_vertical_font_ == value.data_->gdi_vertical_font_ && data_->style_ == value.data_->style_ && data_->size_ == value.data_->size_ && data_->unit_ == value.data_->unit_;}
      bool operator!=(const font& value) const {return !operator==(value);}
      ~font();
      
      xtd::ustring to_string() const noexcept override {
        //return ustring::format("[{}: ]", ustring::class_name(*this));
        return ustring::format("[{}: name={}, size={}, units={}, gdi_char_set={}, gdi_vertical_font={}]", ustring::class_name(*this), data_->font_family_.name(), data_->size_, (int32_t)data_->unit_, data_->gdi_char_set_, data_->gdi_vertical_font_);
      }
      
      friend std::ostream& operator<<(std::ostream& os, const xtd::drawing::font& font) noexcept {return os << font.to_string();}
 
      bool bold() const {return (data_->style_ & font_style::bold) == font_style::bold;}
 
      drawing::font_family font_family() const {return data_->font_family_;}
      
      uint8_t gdi_char_set() const {return data_->gdi_char_set_;}
      
      bool gdi_vertical_font() const {return data_->gdi_vertical_font_;}
      
      intptr_t handle() const {return data_->handle_;}
      
      int32_t height() const;
      
      bool is_system_font() const {return data_->is_system_font_;}
      
      bool italic() const {return (data_->style_ & font_style::italic) == font_style::italic;}
 
      const xtd::ustring& name() const {return data_->font_family_.name();}
 
      const xtd::ustring& original_font_name() const {return data_->original_font_name_;}
      
      float size() const {return data_->size_;}
      
      float size_in_points() const;
      
      bool strikeout() const {return (data_->style_ & font_style::strikeout) == font_style::strikeout;}
 
      font_style style() const {return data_->style_;}
      
      bool underline() const {return (data_->style_ & font_style::underline) == font_style::underline;}
      
      graphics_unit unit() const {return data_->unit_;}
      
      static font from_hdc(const intptr_t hdc);
      
      static font from_hfont(const intptr_t hfont);
      
      float get_height() const;
      
      float get_height(const graphics& graphics) const;
      
      float get_height(float dpi) const;
      
      intptr_t to_hfont() const;
      
    private:
      friend class graphics;
      friend class system_fonts;
      friend class xtd::forms::native::font_dialog;
      font() = default;
      font(intptr_t hfont);
      struct data {
        intptr_t handle_ = 0;
        drawing::font_family font_family_;
        uint8_t gdi_char_set_ = 1;
        bool gdi_vertical_font_ = false;
        bool is_system_font_ = false;
        xtd::ustring original_font_name_;
        float size_ = 8.25f;
        xtd::ustring system_font_name_;
        font_style style_ = font_style::regular;
        graphics_unit unit_ = graphics_unit::point;
      };
      std::shared_ptr<data> data_ = std::make_shared<data>();
    };
  }
}