trunk/RomCheater.EmuMMAPPlugin/EmuMEMMapDockControl.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using WeifenLuo.WinFormsUI.Docking;

namespace RomCheater.EmuMMAPPlugin
{
    public partial class EmuMEMMapDockControl : DockContent
    {
        private List<DeviceMemoryMap> DeviceMemoryMaps = new List<DeviceMemoryMap>();
        public EmuMEMMapDockControl()
        {
            InitializeComponent();
            CreateMaps();
        }
        private void EmuMEMMapDockControl_Shown(object sender, EventArgs e)
        {
            txtDeviceMap.Clear();
            txtDeviceMap.AppendText(string.Format("Device Memory Map(s):{0}", System.Environment.NewLine));
            foreach (var k in DeviceMemoryMaps)
            {
                string devicename = k.DeviceName;
                txtDeviceMap.AppendText(string.Format("{0}:{1}", devicename, System.Environment.NewLine));
                var map = k.MemoryMap;
                foreach (var mapped in map)
                {
                    var mapped_name = mapped.Key;
                    var mapped_data = mapped.Value;
                    var t = mapped_data.ToString();
                    txtDeviceMap.AppendText(string.Format("\t{0}{1}", t, System.Environment.NewLine));
                }
            }
        }
        private void CreateMaps()
        {
            var map = new DeviceMemoryMap();

            #region NES
            map = CreateNESMemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region SNES
            map = CreateSNESMemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region PS1
            map = CreatePS1MemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region PS2
            map = CreatePS2MemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region N64
            map = CreateN64MemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region NGC
            map = CreateNGCMemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region WII
            map = CreateWIIMemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            map = null;
        }

        #region NES
        private DeviceMemoryMap CreateNESMemMap()
        {
            const string name = "NES";
            DeviceMemoryMap map = new DeviceMemoryMap();            
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region SNES
        private DeviceMemoryMap CreateSNESMemMap()
        {
            const string name = "SNES";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region PS1
        private DeviceMemoryMap CreatePS1MemMap()
        {
            const string name = "PS1";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region PS2
        private DeviceMemoryMap CreatePS2MemMap()
        {
            const string name = "PS2";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region N64
        private DeviceMemoryMap CreateN64MemMap()
        {
            const string name = "N64";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region NGC
        private DeviceMemoryMap CreateNGCMemMap()
        {
            const string name = "NGC";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region WII
        private DeviceMemoryMap CreateWIIMemMap()
        {
            const string name = "WII";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
    }

    #region Memory Map Helper Classes
    internal interface IMemMap
    {
        string MapName { get; }
        string MapStart { get; }
        string MapEnd { get; }
        string MapSize { get; }
        string ToString();
    }
    internal interface IDeviceMemoryMap
    {
        string DeviceName { get; }
        IDictionary<string, IMemMap> MemoryMap { get; }
        string ToString();
    }

    internal class MemMap : IMemMap
    {
        public MemMap() : this(string.Empty, 0, 0) { }
        public MemMap(string name)
        {
            this.MapName = name;
        }
        public MemMap(string name, ulong start, ulong end) : this(name, string.Format("0x{0}", start.ToString("X")), string.Format("0x{0}", end.ToString("X")), string.Format("0x{0}", (end - start).ToString("X"))) { }
        public MemMap(string name, string start, string end, string size)
            : this(name)
        {
            this.MapStart = start;
            this.MapEnd = end;
            this.MapSize = size;
        }
        #region IMappedMemRange Members
        public string MapName { get; private set; }
        public string MapStart { get; private set; }
        public string MapEnd { get; private set; }
        public string MapSize { get; private set; }
        public override string ToString()
        {
            return string.Format("[{0}]==>[{1}-{2}] [{3}]", MapName, MapStart, MapEnd, MapSize);
        }
        #endregion
    }

    internal class DeviceMemoryMap : IDeviceMemoryMap
    {
        public DeviceMemoryMap() { this.DeviceName = string.Empty; this.MemoryMap = this.MemoryMap = new Dictionary<string, IMemMap>(); }
        public DeviceMemoryMap(string device, List<IMemMap> memorymap)
        {
            this.DeviceName = device;
            this.MemoryMap = new Dictionary<string, IMemMap>();

            foreach (var map in memorymap)
            {
                this.MemoryMap.Add(map.MapName, map);
            }

        }

        #region IDeviceMemoryMap Members
        public string DeviceName { get; private set; }
        public IDictionary<string, IMemMap> MemoryMap { get; private set; }
        public override string ToString()
        {
            return string.Format("[{0}]==>{1} mapped memory range(s)", DeviceName, MemoryMap.Count);
        }
        #endregion
    }

    #endregion
}

Revision:	641
Committed:	Sat Jun 8 21:50:28 2013 UTC (9 years, 11 months ago) by william
File size:	8302 byte(s)
Log Message:
#	Content
1	using System;
2	using System.Collections.Generic;
3	using System.ComponentModel;
4	using System.Data;
5	using System.Drawing;
6	using System.Linq;
7	using System.Text;
8	using System.Windows.Forms;
9	using WeifenLuo.WinFormsUI.Docking;
10
11	namespace RomCheater.EmuMMAPPlugin
12	{
13	public partial class EmuMEMMapDockControl : DockContent
14	{
15	private List<DeviceMemoryMap> DeviceMemoryMaps = new List<DeviceMemoryMap>();
16	public EmuMEMMapDockControl()
17	{
18	InitializeComponent();
19	CreateMaps();
20	}
21	private void EmuMEMMapDockControl_Shown(object sender, EventArgs e)
22	{
23	txtDeviceMap.Clear();
24	txtDeviceMap.AppendText(string.Format("Device Memory Map(s):{0}", System.Environment.NewLine));
25	foreach (var k in DeviceMemoryMaps)
26	{
27	string devicename = k.DeviceName;
28	txtDeviceMap.AppendText(string.Format("{0}:{1}", devicename, System.Environment.NewLine));
29	var map = k.MemoryMap;
30	foreach (var mapped in map)
31	{
32	var mapped_name = mapped.Key;
33	var mapped_data = mapped.Value;
34	var t = mapped_data.ToString();
35	txtDeviceMap.AppendText(string.Format("\t{0}{1}", t, System.Environment.NewLine));
36	}
37	}
38	}
39	private void CreateMaps()
40	{
41	var map = new DeviceMemoryMap();
42
43	#region NES
44	map = CreateNESMemMap();
45	DeviceMemoryMaps.Add(map);
46	#endregion
47	#region SNES
48	map = CreateSNESMemMap();
49	DeviceMemoryMaps.Add(map);
50	#endregion
51	#region PS1
52	map = CreatePS1MemMap();
53	DeviceMemoryMaps.Add(map);
54	#endregion
55	#region PS2
56	map = CreatePS2MemMap();
57	DeviceMemoryMaps.Add(map);
58	#endregion
59	#region N64
60	map = CreateN64MemMap();
61	DeviceMemoryMaps.Add(map);
62	#endregion
63	#region NGC
64	map = CreateNGCMemMap();
65	DeviceMemoryMaps.Add(map);
66	#endregion
67	#region WII
68	map = CreateWIIMemMap();
69	DeviceMemoryMaps.Add(map);
70	#endregion
71	map = null;
72	}
73
74	#region NES
75	private DeviceMemoryMap CreateNESMemMap()
76	{
77	const string name = "NES";
78	DeviceMemoryMap map = new DeviceMemoryMap();
79	List<IMemMap> maprange = new List<IMemMap>();
80	#region memory maps
81	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
82	#endregion
83	map = new DeviceMemoryMap(name, maprange);
84	return map;
85	}
86	#endregion
87	#region SNES
88	private DeviceMemoryMap CreateSNESMemMap()
89	{
90	const string name = "SNES";
91	DeviceMemoryMap map = new DeviceMemoryMap();
92	List<IMemMap> maprange = new List<IMemMap>();
93	#region memory maps
94	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
95	#endregion
96	map = new DeviceMemoryMap(name, maprange);
97	return map;
98	}
99	#endregion
100	#region PS1
101	private DeviceMemoryMap CreatePS1MemMap()
102	{
103	const string name = "PS1";
104	DeviceMemoryMap map = new DeviceMemoryMap();
105	List<IMemMap> maprange = new List<IMemMap>();
106	#region memory maps
107	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
108	#endregion
109	map = new DeviceMemoryMap(name, maprange);
110	return map;
111	}
112	#endregion
113	#region PS2
114	private DeviceMemoryMap CreatePS2MemMap()
115	{
116	const string name = "PS2";
117	DeviceMemoryMap map = new DeviceMemoryMap();
118	List<IMemMap> maprange = new List<IMemMap>();
119	#region memory maps
120	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
121	#endregion
122	map = new DeviceMemoryMap(name, maprange);
123	return map;
124	}
125	#endregion
126	#region N64
127	private DeviceMemoryMap CreateN64MemMap()
128	{
129	const string name = "N64";
130	DeviceMemoryMap map = new DeviceMemoryMap();
131	List<IMemMap> maprange = new List<IMemMap>();
132	#region memory maps
133	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
134	#endregion
135	map = new DeviceMemoryMap(name, maprange);
136	return map;
137	}
138	#endregion
139	#region NGC
140	private DeviceMemoryMap CreateNGCMemMap()
141	{
142	const string name = "NGC";
143	DeviceMemoryMap map = new DeviceMemoryMap();
144	List<IMemMap> maprange = new List<IMemMap>();
145	#region memory maps
146	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
147	#endregion
148	map = new DeviceMemoryMap(name, maprange);
149	return map;
150	}
151	#endregion
152	#region WII
153	private DeviceMemoryMap CreateWIIMemMap()
154	{
155	const string name = "WII";
156	DeviceMemoryMap map = new DeviceMemoryMap();
157	List<IMemMap> maprange = new List<IMemMap>();
158	#region memory maps
159	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
160	#endregion
161	map = new DeviceMemoryMap(name, maprange);
162	return map;
163	}
164	#endregion
165	}
166
167	#region Memory Map Helper Classes
168	internal interface IMemMap
169	{
170	string MapName { get; }
171	string MapStart { get; }
172	string MapEnd { get; }
173	string MapSize { get; }
174	string ToString();
175	}
176	internal interface IDeviceMemoryMap
177	{
178	string DeviceName { get; }
179	IDictionary<string, IMemMap> MemoryMap { get; }
180	string ToString();
181	}
182
183	internal class MemMap : IMemMap
184	{
185	public MemMap() : this(string.Empty, 0, 0) { }
186	public MemMap(string name)
187	{
188	this.MapName = name;
189	}
190	public MemMap(string name, ulong start, ulong end) : this(name, string.Format("0x{0}", start.ToString("X")), string.Format("0x{0}", end.ToString("X")), string.Format("0x{0}", (end - start).ToString("X"))) { }
191	public MemMap(string name, string start, string end, string size)
192	: this(name)
193	{
194	this.MapStart = start;
195	this.MapEnd = end;
196	this.MapSize = size;
197	}
198	#region IMappedMemRange Members
199	public string MapName { get; private set; }
200	public string MapStart { get; private set; }
201	public string MapEnd { get; private set; }
202	public string MapSize { get; private set; }
203	public override string ToString()
204	{
205	return string.Format("[{0}]==>[{1}-{2}] [{3}]", MapName, MapStart, MapEnd, MapSize);
206	}
207	#endregion
208	}
209
210	internal class DeviceMemoryMap : IDeviceMemoryMap
211	{
212	public DeviceMemoryMap() { this.DeviceName = string.Empty; this.MemoryMap = this.MemoryMap = new Dictionary<string, IMemMap>(); }
213	public DeviceMemoryMap(string device, List<IMemMap> memorymap)
214	{
215	this.DeviceName = device;
216	this.MemoryMap = new Dictionary<string, IMemMap>();
217
218	foreach (var map in memorymap)
219	{
220	this.MemoryMap.Add(map.MapName, map);
221	}
222
223	}
224
225	#region IDeviceMemoryMap Members
226	public string DeviceName { get; private set; }
227	public IDictionary<string, IMemMap> MemoryMap { get; private set; }
228	public override string ToString()
229	{
230	return string.Format("[{0}]==>{1} mapped memory range(s)", DeviceName, MemoryMap.Count);
231	}
232	#endregion
233	}
234
235	#endregion
236	}
237