summaryrefslogtreecommitdiffstatshomepage
path: root/src/osd/modules/monitor/monitor_module.h
blob: 3244e7fd42b0d079820629e43cec8880388523b4 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// license:BSD-3-Clause
// copyright-holders:Brad Hughes, Aaron Giles, Olivier Galibert, R. Belmont
/*
 * monitor_module.h
 *
 */

#ifndef MAME_OSD_MODULES_MONITOR_MONITORMODULE_H
#define MAME_OSD_MODULES_MONITOR_MONITORMODULE_H

#include <vector>

#include "modules/osdmodule.h"
#include "modules/osdhelper.h"

//============================================================
//  CONSTANTS
//============================================================

#define OSD_MONITOR_PROVIDER   "monitorprovider"

class monitor_module;
class osd_window;

//============================================================
//  osd_monitor_info
//============================================================

class osd_monitor_info
{
public:
	osd_monitor_info(monitor_module &module, std::uint64_t handle, const char *monitor_device, float aspect)
		: m_is_primary(false), m_name(monitor_device), m_module(module), m_handle(handle), m_aspect(aspect)
	{
	}

	virtual ~osd_monitor_info() { }

	virtual void refresh() = 0;

	std::uint64_t oshandle() const { return m_handle; }
	monitor_module& module() const { return m_module; }

	const osd_rect &position_size() const { return m_pos_size; }
	const osd_rect &usuable_position_size() const { return m_usuable_pos_size; }

	const std::string &devicename() const
	{
		static std::string s_unknown = std::string("UNKNOWN");
		return m_name.length() ? m_name : s_unknown;
	}

	float aspect() const { return m_aspect; }
	float pixel_aspect() const { return m_aspect / (float(m_pos_size.width()) / float(m_pos_size.height())); }

	void update_resolution(const int new_width, const int new_height) const { m_pos_size.resize(new_width, new_height); }
	void set_aspect(const float a) { m_aspect = a; }
	bool is_primary() const { return m_is_primary; }

protected:
	osd_rect            m_pos_size;
	osd_rect            m_usuable_pos_size;
	bool                m_is_primary;
	std::string         m_name;
private:
	monitor_module&     m_module;
	std::uint64_t       m_handle;                 // handle to the monitor
	float               m_aspect;                 // computed/configured aspect ratio of the physical device
};

//============================================================
//  monitor_module
//============================================================

class monitor_module : public osd_module
{
private:
	std::vector<std::shared_ptr<osd_monitor_info>> m_list;

public:
	monitor_module(const char *type, const char *name)
		: osd_module(type, name)
	{
	}

	virtual ~monitor_module() { }

	std::vector<std::shared_ptr<osd_monitor_info>> & list() { return m_list; }

	virtual std::shared_ptr<osd_monitor_info> monitor_from_handle(std::uint64_t handle) = 0;
	virtual std::shared_ptr<osd_monitor_info> monitor_from_rect(const osd_rect &rect) = 0;
	virtual std::shared_ptr<osd_monitor_info> monitor_from_window(const osd_window &window) = 0;

	virtual std::shared_ptr<osd_monitor_info> pick_monitor(osd_options &options, int index) = 0;
};

#endif // MAME_OSD_MODULES_MONITOR_MONITORMODULE_H