screen.h

Go to the documentation of this file.

#pragma once
#include <cstdint>
#include <string>
#include <vector>
#include <xtd/object.h>
#include <xtd/drawing/rectangle.h>
#include "control.h"
 
namespace xtd {
  namespace forms {
    class forms_export_ screen : public object {
    public:
      screen(const screen&) = default;
      screen& operator=(const screen&) = default;
      
      static std::vector<screen> all_screens();
 
      int32_t bits_per_pixel() const {return bits_per_pixel_;}
      
      const drawing::rectangle& bounds() const {return bounds_;}
      
      const xtd::ustring& device_name() const {return device_name_;}
      
      bool high_resolution() const {return scale_factor_ > 1.;}
 
      int32_t pixels_per_inch() const {return pixels_per_inch_;}
      
      bool primary() const {return primary_;}
      
      double scale_factor() const {return scale_factor_;}
 
      static screen primary_screen() {
        std::vector<screen> screens = all_screens();
        for (auto& screen : screens)
          if (screen.primary()) return screen;
        return screens[0];
      }
      
      const drawing::rectangle& working_area() const {return working_area_;}
      
      static drawing::graphics create_graphics();
 
      static screen from_control(const control& control);
      
      static screen from_handle(intptr_t handle);
 
      static screen from_point(const drawing::point& point);
      
      static screen from_rectangle(const drawing::rectangle& rect);
      
      static drawing::rectangle get_bounds(const control& control);
      
      static drawing::rectangle get_bounds(intptr_t handle);
      
      static drawing::rectangle get_bounds(const drawing::point& point);
      
      static drawing::rectangle get_bounds(const drawing::rectangle& rect);
      
      static int32_t get_standard_pixels_per_inch();
      
      static drawing::rectangle get_working_area(const control& control);
      
      static drawing::rectangle get_working_area(intptr_t handle);
      
      static drawing::rectangle get_working_area(const drawing::point& point);
      
      static drawing::rectangle get_working_area(const drawing::rectangle& rect);
                                  
    private:
      screen() = default;
      screen(int32_t bits_per_pixel, const drawing::rectangle& bounds, const xtd::ustring& device_name, int32_t pixels_per_inch, bool primary, double scale_factor, const drawing::rectangle& working_area) : bits_per_pixel_(bits_per_pixel), bounds_(bounds), device_name_(device_name), pixels_per_inch_(pixels_per_inch), primary_(primary), scale_factor_(scale_factor), working_area_(working_area) {}
      
      int32_t bits_per_pixel_ = 0;
      drawing::rectangle bounds_;
      xtd::ustring device_name_;
      int32_t pixels_per_inch_ = 96;
      bool primary_ = false;
      double scale_factor_ = 1.;
      drawing::rectangle working_area_;
    };                           
  }
}