summaryrefslogtreecommitdiffstatshomepage
path: root/src/osd/modules/debugger/qt/memorywindow.h
blob: 75b3c994bb7f2911054d5a318913046924d7753f (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
98
// license:BSD-3-Clause
// copyright-holders:Andrew Gardner
#ifndef __DEBUG_QT_MEMORY_WINDOW_H__
#define __DEBUG_QT_MEMORY_WINDOW_H__

#include <QtGui/QtGui>

#include "debuggerview.h"
#include "windowqt.h"

class DebuggerMemView;


//============================================================
//  The Memory Window.
//============================================================
class MemoryWindow : public WindowQt
{
	Q_OBJECT

public:
	MemoryWindow(running_machine* machine, QWidget* parent=NULL);
	virtual ~MemoryWindow();


private slots:
	void memoryRegionChanged(int index);
	void expressionSubmitted();
	void formatChanged(QAction* changedTo);
	void addressChanged(QAction* changedTo);
	void reverseChanged(bool changedTo);
	void increaseBytesPerLine(bool changedTo);
	void decreaseBytesPerLine(bool checked=false);


private:
	void populateComboBox();
	void setToCurrentCpu();
	QAction* dataFormatMenuItem(const QString& itemName);


private:
	// Widgets
	QLineEdit* m_inputEdit;
	QComboBox* m_memoryComboBox;
	DebuggerMemView* m_memTable;
};


//=========================================================================
//  The mem window gets its own debugger view to handle right click pop-ups
//=========================================================================
class DebuggerMemView : public DebuggerView
{
public:
	DebuggerMemView(const debug_view_type& type,
					running_machine* machine,
					QWidget* parent=NULL)
		: DebuggerView(type, machine, parent)
	{}
	virtual ~DebuggerMemView() {}

protected:
	void mousePressEvent(QMouseEvent* event);
};


//=========================================================================
//  A way to store the configuration of a window long enough to read/write.
//=========================================================================
class MemoryWindowQtConfig : public WindowQtConfig
{
public:
	MemoryWindowQtConfig() :
		WindowQtConfig(WIN_TYPE_MEMORY),
		m_reverse(0),
		m_addressMode(0),
		m_dataFormat(0),
		m_memoryRegion(0)
	{
	}

	~MemoryWindowQtConfig() {}

	// Settings
	int m_reverse;
	int m_addressMode;
	int m_dataFormat;
	int m_memoryRegion;

	void buildFromQWidget(QWidget* widget);
	void applyToQWidget(QWidget* widget);
	void addToXmlDataNode(xml_data_node* node) const;
	void recoverFromXmlNode(xml_data_node* node);
};


#endif
an> }; class options_warning_exception : public options_exception { public: template <typename... Params> options_warning_exception(const char *fmt, Params &&...args) : options_warning_exception(util::string_format(fmt, std::forward<Params>(args)...)) { } options_warning_exception(std::string &&message); options_warning_exception(const options_warning_exception &) = default; options_warning_exception(options_warning_exception &&) = default; options_warning_exception& operator=(const options_warning_exception &) = default; options_warning_exception& operator=(options_warning_exception &&) = default; }; class options_error_exception : public options_exception { public: template <typename... Params> options_error_exception(const char *fmt, Params &&...args) : options_error_exception(util::string_format(fmt, std::forward<Params>(args)...)) { } options_error_exception(std::string &&message); options_error_exception(const options_error_exception &) = default; options_error_exception(options_error_exception &&) = default; options_error_exception& operator=(const options_error_exception &) = default; options_error_exception& operator=(options_error_exception &&) = default; }; // structure holding information about a collection of options class core_options { static const int MAX_UNADORNED_OPTIONS = 16; public: enum class option_type { INVALID, // invalid HEADER, // a header item COMMAND, // a command BOOLEAN, // boolean option INTEGER, // integer option FLOAT, // floating-point option STRING // string option }; // information about a single entry in the options class entry { public: typedef std::shared_ptr<entry> shared_ptr; typedef std::weak_ptr<entry> weak_ptr; // constructor/destructor entry(std::vector<std::string> &&names, option_type type = option_type::STRING, const char *description = nullptr); entry(std::string &&name, option_type type = option_type::STRING, const char *description = nullptr); entry(const entry &) = delete; entry(entry &&) = delete; entry& operator=(const entry &) = delete; entry& operator=(entry &&) = delete; virtual ~entry(); // accessors const std::vector<std::string> &names() const { return m_names; } const std::string &name() const { return m_names[0]; } virtual const char *value() const; int priority() const { return m_priority; } void set_priority(int priority) { m_priority = priority; } option_type type() const { return m_type; } const char *description() const { return m_description; } virtual const std::string &default_value() const; virtual const char *minimum() const; virtual const char *maximum() const; bool has_range() const; // mutators void set_value(std::string &&newvalue, int priority, bool always_override = false); virtual void set_default_value(std::string &&newvalue); void set_description(const char *description) { m_description = description; } void set_value_changed_handler(std::function<void(const char *)> &&handler) { m_value_changed_handler = std::move(handler); } virtual void revert(int priority_hi, int priority_lo) { } protected: virtual void internal_set_value(std::string &&newvalue) = 0; private: void validate(const std::string &value); std::vector<std::string> m_names; int m_priority; core_options::option_type m_type; const char * m_description; std::function<void(const char *)> m_value_changed_handler; }; // construction/destruction core_options(); core_options(const core_options &) = delete; core_options(core_options &&) = default; core_options& operator=(const core_options &) = delete; core_options& operator=(core_options &&) = default; virtual ~core_options(); // getters const std::string &command() const { return m_command; } const std::vector<std::string> &command_arguments() const { assert(!m_command.empty()); return m_command_arguments; } const entry::shared_ptr get_entry(const std::string &name) const; entry::shared_ptr get_entry(const std::string &name); const std::vector<entry::shared_ptr> &entries() const { return m_entries; } bool exists(const std::string &name) const { return get_entry(name) != nullptr; } bool header_exists(const char *description) const; // configuration void add_entry(entry::shared_ptr &&entry, const char *after_header = nullptr); void add_entry(const options_entry &entry, bool override_existing = false); void add_entry(std::vector<std::string> &&names, const char *description, option_type type, std::string &&default_value = "", std::string &&minimum = "", std::string &&maximum = ""); void add_header(const char *description); void add_entries(const options_entry *entrylist, bool override_existing = false); void set_default_value(const char *name, const char *defvalue); void set_description(const char *name, const char *description); void remove_entry(entry &delentry); void set_value_changed_handler(const std::string &name, std::function<void(const char *)> &&handler); void revert(int priority_hi = OPTION_PRIORITY_MAXIMUM, int priority_lo = OPTION_PRIORITY_DEFAULT); // parsing/input void parse_command_line(const std::vector<std::string> &args, int priority, bool ignore_unknown_options = false); void parse_ini_file(util::core_file &inifile, int priority, bool ignore_unknown_options, bool always_override); void copy_from(const core_options &that); // output std::string output_ini(const core_options *diff = nullptr) const; std::string output_help() const; // reading const char *value(const char *option) const; const char *description(const char *option) const; bool bool_value(const char *option) const { return int_value(option) != 0; } int int_value(const char *option) const { return atoi(value(option)); } float float_value(const char *option) const { return atof(value(option)); } // setting void set_value(const std::string &name, const std::string &value, int priority); void set_value(const std::string &name, std::string &&value, int priority); void set_value(const std::string &name, int value, int priority); void set_value(const std::string &name, float value, int priority); // misc static const char *unadorned(int x = 0) { return s_option_unadorned[std::min(x, MAX_UNADORNED_OPTIONS - 1)]; } protected: virtual void command_argument_processed() { } private: class simple_entry : public entry { public: // construction/destruction simple_entry(std::vector<std::string> &&names, const char *description, core_options::option_type type, std::string &&defdata, std::string &&minimum, std::string &&maximum); simple_entry(const simple_entry &) = delete; simple_entry(simple_entry &&) = delete; simple_entry& operator=(const simple_entry &) = delete; simple_entry& operator=(simple_entry &&) = delete; ~simple_entry(); // getters virtual const char *value() const override; virtual const char *minimum() const override; virtual const char *maximum() const override; virtual const std::string &default_value() const override; virtual void revert(int priority_hi, int priority_lo) override; virtual void set_default_value(std::string &&newvalue) override; protected: virtual void internal_set_value(std::string &&newvalue) override; private: // internal state std::string m_data; // data for this item std::string m_defdata; // default data for this item std::string m_minimum; // minimum value std::string m_maximum; // maximum value }; // used internally in core_options enum class condition_type { NONE, WARN, ERR }; // internal helpers void add_to_entry_map(std::string &&name, entry::shared_ptr &entry); void do_set_value(entry &curentry, std::string &&data, int priority, std::ostream &error_stream, condition_type &condition); void throw_options_exception_if_appropriate(condition_type condition, std::ostringstream &error_stream); // internal state std::vector<entry::shared_ptr> m_entries; // cannonical list of entries std::unordered_map<std::string, entry::weak_ptr> m_entrymap; // map for fast lookup std::string m_command; // command found std::vector<std::string> m_command_arguments; // command arguments static const char *const s_option_unadorned[]; // array of unadorned option "names" }; // static structure describing a single option with its description and default value struct options_entry { const char * name; // name on the command line const char * defvalue; // default value of this argument core_options::option_type type; // type of option const char * description; // description for -showusage }; // legacy option types const core_options::option_type OPTION_INVALID = core_options::option_type::INVALID; const core_options::option_type OPTION_HEADER = core_options::option_type::HEADER; const core_options::option_type OPTION_COMMAND = core_options::option_type::COMMAND; const core_options::option_type OPTION_BOOLEAN = core_options::option_type::BOOLEAN; const core_options::option_type OPTION_INTEGER = core_options::option_type::INTEGER; const core_options::option_type OPTION_FLOAT = core_options::option_type::FLOAT; const core_options::option_type OPTION_STRING = core_options::option_type::STRING; #endif // MAME_LIB_UTIL_OPTIONS_H