trunk/RomCheater.RVACheatList/RVACheatListDockControl.cs

//#region Logging Defines
//// include this any class or method that required logging, and comment-out what is not needed

//#region Enabled logging levels
//#define LOGGING_ENABLE_INFO
//#define LOGGING_ENABLE_WARN
//#define LOGGING_ENABLE_DEBUG
//#define LOGGING_ENABLE_VERBOSEDEBUG
//#define LOGGING_ENABLE_ERROR
//#define LOGGING_ENABLE_VERBOSEERROR
//#define LOGGING_ENABLE_PROFILER
//#endregion
//#endregion
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;
using RomCheater.Logging;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using RomCheater.PluginFramework.Core;
using RomCheater.Core;
using Enterprise.Logging;

namespace RomCheater.RVACheatList
{
    public partial class RVACheatListDockControl : DockContent
    {
        private UserControlPlugin plugin;
        public RVACheatListDockControl(UserControlPlugin plugin)
        {
            this.plugin = plugin;
            InitPluginFramework();
            InitializeComponent();
            this.Icon = Core.Properties.Resources.romcheater_icon;
        }
        private void InitPluginFramework()
        {
            if (this.plugin == null) { return; }
            this.plugin.OnSelectedProcessChanged += new BaseEventHandler<ProcessChangedEventArgs>(plugin_OnSelectedProcessChanged);
            this.plugin.OnSelectedConfigChanged += new BaseEventHandler<ConfigChangedEventArgs>(plugin_OnSelectedConfigChanged);
            this.plugin.OnPEDataUpdated += new BaseEventHandler<PEViewerDataUpdatedEventArgs>(plugin_OnPEDataUpdated);
            RaisePluginFrameworkEvents();
        }

        bool EventsRaised = false;
        private void RaisePluginFrameworkEvents()
        {

            if (this.plugin == null) { EventsRaised = true; return; }
            if (!EventsRaised)
            {
                this.plugin.RaisePluginFrameworkEvents();
                EventsRaised = true;
            }
        }
        void plugin_OnPEDataUpdated(PEViewerDataUpdatedEventArgs e)
        {
            //logger.Warn.WriteLine("plugin_OnPEDataUpdated::has not been implemented!");
        }
        void plugin_OnSelectedConfigChanged(ConfigChangedEventArgs e)
        {
            //logger.Warn.WriteLine("plugin_OnSelectedConfigChanged::has not been implemented!");
        }
        void plugin_OnSelectedProcessChanged(ProcessChangedEventArgs e)
        {
            //logger.Warn.WriteLine("plugin_OnSelectedProcessChanged::has not been implemented!");
        }


        private void ResizeColumns()
        {
            foreach (var col in Enumerable.Range(0, lstCheats.Columns.Count))
            {
                lstCheats.AutoResizeColumn(col, ColumnHeaderAutoResizeStyle.ColumnContent);
                lstCheats.AutoResizeColumn(col, ColumnHeaderAutoResizeStyle.HeaderSize);
            }
        }

        private void btnAdd_Click(object sender, EventArgs e)
        {
            CheatInputDialog dlg = new CheatInputDialog();
            DialogResult result = dlg.ShowDialog();
            if (result == DialogResult.Cancel) { return; }
            uint physical = dlg.CheatAddress + txtRVA.ToUInt32();
            ListViewItem li = new ListViewItem(dlg.CheatName);
            li.SubItems.Add(new ListViewItem.ListViewSubItem(li, string.Format("0x{0:x8}", dlg.CheatAddress)));
            li.SubItems.Add(new ListViewItem.ListViewSubItem(li, string.Format("0x{0:x8}", physical)));
            lstCheats.Items.Add(li);
            ResizeColumns();
        }

        private void btnRemove_Click(object sender, EventArgs e)
        {
            if (lstCheats.SelectedItems.Count == 0 || lstCheats.SelectedItems.Count > 1) { return; }
            int index = lstCheats.SelectedIndices[0];
            lstCheats.Items.RemoveAt(index);
            ResizeColumns();
        }

        private void btnUpdate_Click(object sender, EventArgs e)
        {
            if (lstCheats.SelectedItems.Count == 0 || lstCheats.SelectedItems.Count > 1) { return; }
            int index = lstCheats.SelectedIndices[0];
            var li = lstCheats.SelectedItems[0];
            string name = li.Text;
            string address = li.SubItems[1].Text;

            CheatInputDialog dlg = new CheatInputDialog(name, Convert.ToUInt32(address, 16));
            DialogResult result = dlg.ShowDialog();
            if (result == DialogResult.Cancel) { return; }
            uint physical = dlg.CheatAddress + txtRVA.ToUInt32();
            li.Text = dlg.CheatName;
            li.SubItems[1].Text = string.Format("0x{0:x8}", dlg.CheatAddress);
            li.SubItems[2].Text = string.Format("0x{0:x8}", physical);
            lstCheats.Items[index] = li;
            ResizeColumns();
        }

        private void btnCopy_Click(object sender, EventArgs e)
        {
            if (lstCheats.SelectedItems.Count == 0 || lstCheats.SelectedItems.Count > 1) { return; }
            var li = lstCheats.SelectedItems[0];
            string physical = li.SubItems[2].Text;
            Clipboard.SetText(physical);
        }

        private void btnSave_Click(object sender, EventArgs e)
        {
            DialogResult result = CheatSaver.ShowDialog();
            if (result != DialogResult.OK) { return; }

            
            ICheatList2 list = new ICheatList2();
            list.RVA = txtRVA.ToUInt32();
            List<ICheatEntry2> cheats = new List<ICheatEntry2>();
            foreach (ListViewItem li in lstCheats.Items)
            {
                cheats.Add(new ICheatEntry2(li.Text, Convert.ToUInt32(li.SubItems[1].Text, 16), Convert.ToUInt32(li.SubItems[2].Text, 16)));
            }

            list.Cheats = cheats;

            try
            {
                using (FileStream fs = new FileStream(CheatSaver.FileName, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
                {
                    try
                    {
                        fs.Seek(0, SeekOrigin.Begin);
                        BinaryFormatter bin = new BinaryFormatter();
                        bin.Serialize(fs, list);
                    }
                    catch (Exception ex)
                    {
                        gLog.Error.WriteLine("Failed to save file: {0}", CheatSaver.FileName);
                        gLog.Verbose.Error.WriteLine(ex.ToString());
                        MessageBox.Show(string.Format("Failed to save: '{0}'", new FileInfo(CheatSaver.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }
                }
                MessageBox.Show(string.Format("Successfully saved file: '{0}'", new FileInfo(CheatSaver.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                gLog.Error.WriteLine("Failed to save file: {0}", CheatSaver.FileName);
                gLog.Verbose.Error.WriteLine(ex.ToString());
                MessageBox.Show(string.Format("Failed to save: '{0}'", new FileInfo(CheatSaver.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void btnLoad_Click(object sender, EventArgs e)
        {
            DialogResult result = CheatLoader.ShowDialog();
            if (result != DialogResult.OK) { return; }
            try
            {
                using (FileStream fs = new FileStream(CheatLoader.FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    try
                    {
                        ICheatList2 list = new ICheatList2();
                        BinaryFormatter bin = new BinaryFormatter();
                        try
                        {
                            fs.Seek(0, SeekOrigin.Begin);
                            var t_list = (ICheatList2)bin.Deserialize(fs);
                            list = t_list;
                        }
                        catch (Exception)
                        {
                            fs.Seek(0, SeekOrigin.Begin);
                            var t_list = (ICheatList)bin.Deserialize(fs);
                            list = new ICheatList2(t_list);
                        }

                        txtRVA.Value = list.RVA;
                        if (lstCheats.Items.Count > 0)
                        {
                            result = MessageBox.Show("Clear existing Cheats?", "", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button3);
                            if (result == System.Windows.Forms.DialogResult.Cancel)
                            {
                                // assume abort of load
                                gLog.Warn.WriteLine("Abored processing of file (by user request): {0}", CheatLoader.FileName);
                                fs.Close();
                                return;
                            }
                            if (result == DialogResult.Yes)
                            {
                                lstCheats.Items.Clear();
                            }
                        }
                        foreach (var cheat in list.Cheats)
                        {
                            ListViewItem li = new ListViewItem(cheat.CheatName);
                            li.SubItems.Add(new ListViewItem.ListViewSubItem(li, string.Format("0x{0:x8}", cheat.CheatAddress)));
                            uint physical = cheat.CheatAddress + list.RVA;
                            li.SubItems.Add(new ListViewItem.ListViewSubItem(li, string.Format("0x{0:x8}", physical)));
                            lstCheats.Items.Add(li);
                        }
                        btnRefresh.PerformClick(); // do any needed refreshing
                    }
                    catch (Exception ex)
                    {
                        gLog.Error.WriteLine("Failed to load file: {0}", CheatLoader.FileName);
                        gLog.Verbose.Error.WriteLine(ex.ToString());
                        MessageBox.Show(string.Format("Failed to open: '{0}'", new FileInfo(CheatLoader.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }
                }
                //MessageBox.Show(string.Format("Successfully opened file: '{0}'", new FileInfo(CheatLoader.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                gLog.Error.WriteLine("Failed to load file: {0}", CheatLoader.FileName);
                gLog.Verbose.Error.WriteLine(ex.ToString());
                MessageBox.Show(string.Format("Failed to open: '{0}'", new FileInfo(CheatLoader.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            ResizeColumns();
        }

        private void btnRefresh_Click(object sender, EventArgs e)
        {
            int index = 0;
            foreach (ListViewItem li in lstCheats.Items)
            {
                string name = li.Text;
                string address = li.SubItems[1].Text;
                uint physical = Convert.ToUInt32(address, 16) + txtRVA.ToUInt32();
                li.SubItems[2].Text = string.Format("0x{0:x8}", physical);                
                lstCheats.Items[index] = li;
                index++;
            }
            ResizeColumns();
        }
        private void btnCopyAll_Click(object sender, EventArgs e)
        {
            ICheatList2 list = new ICheatList2();
            list.RVA = txtRVA.ToUInt32();
            List<ICheatEntry2> cheats = new List<ICheatEntry2>();
            foreach (ListViewItem li in lstCheats.Items)
            {
                cheats.Add(new ICheatEntry2(li.Text, Convert.ToUInt32(li.SubItems[1].Text, 16), Convert.ToUInt32(li.SubItems[2].Text, 16)));
            }
            list.Cheats = cheats;
            StringBuilder builder = new StringBuilder();
            builder.AppendFormat("RVA: 0x{0:x8}", list.RVA);
            builder.AppendLine();
            foreach (ColumnHeader t in lstCheats.Columns)
            {
                builder.AppendFormat("{0}:\t\t", t.Text);
            }
            builder.AppendLine();
            foreach (var cheat in list.Cheats)
            {
                builder.AppendFormat("{0}\t\t0x{1:x8}\t\t0x{2:x8}", cheat.CheatName, cheat.CheatAddress, cheat.PhysicalAddress);
                builder.AppendLine();
            }
            Clipboard.SetText(builder.ToString());

        }
        private void RVACalculatorDockControl_Shown(object sender, EventArgs e)
        {
            //const int t = 100;
            ////txtRVA.SuspendLayout();
            //logger.Debug.WriteLine("txtRva.Width={0}", txtRVA.Width);
            //logger.Debug.WriteLine("increasing txtRva.Width to {0}", txtRVA.Width + t);
            //txtRVA.Width = txtRVA.Width + t;
            //logger.Debug.WriteLine("txtRva.Width={0}", txtRVA.Width);
            ////txtRVA.ResumeLayout();
        }

        [Serializable]
        private struct ICheatEntry
        {
            public ICheatEntry(string name, uint address)
            {
                CheatName = name;
                CheatAddress = address;
            }
            public string CheatName;
            public uint CheatAddress;
        }
        [Serializable]
        private struct ICheatEntry2
        {
            public ICheatEntry2(string name, uint address, uint physical)
            {
                CheatName = name;
                CheatAddress = address;
                PhysicalAddress = physical;
            }
            public string CheatName;
            public uint CheatAddress;
            public uint PhysicalAddress;
        }
        [Serializable]
        private struct ICheatList
        {
            public ICheatList(ICheatList2 t)
            {
                RVA = t.RVA;
                List<ICheatEntry> cheats = new List<ICheatEntry>();
                t.Cheats.ForEach(c => cheats.Add(new ICheatEntry(c.CheatName,c.CheatAddress)));
                Cheats = cheats;
            }
            public ICheatList(uint rva, List<ICheatEntry> cheats)
            {
                RVA = rva;
                Cheats = cheats;
            }
            public uint RVA;
            public List<ICheatEntry> Cheats;
        }
        [Serializable]
        private struct ICheatList2
        {
            public ICheatList2(ICheatList t)
            {
                RVA = t.RVA;
                List<ICheatEntry2> cheats = new List<ICheatEntry2>();
                t.Cheats.ForEach(c => cheats.Add(new ICheatEntry2(c.CheatName, c.CheatAddress, c.CheatAddress)));
                Cheats = cheats;
            }
            public ICheatList2(uint rva, List<ICheatEntry2> cheats)
            {
                RVA = rva;
                Cheats = cheats;
            }
            public uint RVA;
            public List<ICheatEntry2> Cheats;
        }

        private void txtRVA_ValueChanged(object sender, ValueChangedEventArgs e)
        {
            btnRefresh.PerformClick();
        }
      

    }
}
Revision:	857
Committed:	Tue Sep 16 21:32:29 2014 UTC (8 years, 8 months ago) by william
File size:	15697 byte(s)
Log Message:
#	User	Rev	Content
1	william	857	//#region Logging Defines
2			//// include this any class or method that required logging, and comment-out what is not needed
3
4			//#region Enabled logging levels
5			//#define LOGGING_ENABLE_INFO
6			//#define LOGGING_ENABLE_WARN
7			//#define LOGGING_ENABLE_DEBUG
8			//#define LOGGING_ENABLE_VERBOSEDEBUG
9			//#define LOGGING_ENABLE_ERROR
10			//#define LOGGING_ENABLE_VERBOSEERROR
11			//#define LOGGING_ENABLE_PROFILER
12			//#endregion
13			//#endregion
14			using System;
15			using System.Collections.Generic;
16			using System.ComponentModel;
17			using System.Data;
18			using System.Drawing;
19			using System.Linq;
20			using System.Text;
21			using System.Windows.Forms;
22			using WeifenLuo.WinFormsUI.Docking;
23			using RomCheater.Logging;
24			using System.IO;
25			using System.Runtime.Serialization.Formatters.Binary;
26			using RomCheater.PluginFramework.Core;
27			using RomCheater.Core;
28			using Enterprise.Logging;
29
30			namespace RomCheater.RVACheatList
31			{
32			public partial class RVACheatListDockControl : DockContent
33			{
34			private UserControlPlugin plugin;
35			public RVACheatListDockControl(UserControlPlugin plugin)
36			{
37			this.plugin = plugin;
38			InitPluginFramework();
39			InitializeComponent();
40			this.Icon = Core.Properties.Resources.romcheater_icon;
41			}
42			private void InitPluginFramework()
43			{
44			if (this.plugin == null) { return; }
45			this.plugin.OnSelectedProcessChanged += new BaseEventHandler<ProcessChangedEventArgs>(plugin_OnSelectedProcessChanged);
46			this.plugin.OnSelectedConfigChanged += new BaseEventHandler<ConfigChangedEventArgs>(plugin_OnSelectedConfigChanged);
47			this.plugin.OnPEDataUpdated += new BaseEventHandler<PEViewerDataUpdatedEventArgs>(plugin_OnPEDataUpdated);
48			RaisePluginFrameworkEvents();
49			}
50
51			bool EventsRaised = false;
52			private void RaisePluginFrameworkEvents()
53			{
54
55			if (this.plugin == null) { EventsRaised = true; return; }
56			if (!EventsRaised)
57			{
58			this.plugin.RaisePluginFrameworkEvents();
59			EventsRaised = true;
60			}
61			}
62			void plugin_OnPEDataUpdated(PEViewerDataUpdatedEventArgs e)
63			{
64			//logger.Warn.WriteLine("plugin_OnPEDataUpdated::has not been implemented!");
65			}
66			void plugin_OnSelectedConfigChanged(ConfigChangedEventArgs e)
67			{
68			//logger.Warn.WriteLine("plugin_OnSelectedConfigChanged::has not been implemented!");
69			}
70			void plugin_OnSelectedProcessChanged(ProcessChangedEventArgs e)
71			{
72			//logger.Warn.WriteLine("plugin_OnSelectedProcessChanged::has not been implemented!");
73			}
74
75
76			private void ResizeColumns()
77			{
78			foreach (var col in Enumerable.Range(0, lstCheats.Columns.Count))
79			{
80			lstCheats.AutoResizeColumn(col, ColumnHeaderAutoResizeStyle.ColumnContent);
81			lstCheats.AutoResizeColumn(col, ColumnHeaderAutoResizeStyle.HeaderSize);
82			}
83			}
84
85			private void btnAdd_Click(object sender, EventArgs e)
86			{
87			CheatInputDialog dlg = new CheatInputDialog();
88			DialogResult result = dlg.ShowDialog();
89			if (result == DialogResult.Cancel) { return; }
90			uint physical = dlg.CheatAddress + txtRVA.ToUInt32();
91			ListViewItem li = new ListViewItem(dlg.CheatName);
92			li.SubItems.Add(new ListViewItem.ListViewSubItem(li, string.Format("0x{0:x8}", dlg.CheatAddress)));
93			li.SubItems.Add(new ListViewItem.ListViewSubItem(li, string.Format("0x{0:x8}", physical)));
94			lstCheats.Items.Add(li);
95			ResizeColumns();
96			}
97
98			private void btnRemove_Click(object sender, EventArgs e)
99			{
100			if (lstCheats.SelectedItems.Count == 0 \|\| lstCheats.SelectedItems.Count > 1) { return; }
101			int index = lstCheats.SelectedIndices[0];
102			lstCheats.Items.RemoveAt(index);
103			ResizeColumns();
104			}
105
106			private void btnUpdate_Click(object sender, EventArgs e)
107			{
108			if (lstCheats.SelectedItems.Count == 0 \|\| lstCheats.SelectedItems.Count > 1) { return; }
109			int index = lstCheats.SelectedIndices[0];
110			var li = lstCheats.SelectedItems[0];
111			string name = li.Text;
112			string address = li.SubItems[1].Text;
113
114			CheatInputDialog dlg = new CheatInputDialog(name, Convert.ToUInt32(address, 16));
115			DialogResult result = dlg.ShowDialog();
116			if (result == DialogResult.Cancel) { return; }
117			uint physical = dlg.CheatAddress + txtRVA.ToUInt32();
118			li.Text = dlg.CheatName;
119			li.SubItems[1].Text = string.Format("0x{0:x8}", dlg.CheatAddress);
120			li.SubItems[2].Text = string.Format("0x{0:x8}", physical);
121			lstCheats.Items[index] = li;
122			ResizeColumns();
123			}
124
125			private void btnCopy_Click(object sender, EventArgs e)
126			{
127			if (lstCheats.SelectedItems.Count == 0 \|\| lstCheats.SelectedItems.Count > 1) { return; }
128			var li = lstCheats.SelectedItems[0];
129			string physical = li.SubItems[2].Text;
130			Clipboard.SetText(physical);
131			}
132
133			private void btnSave_Click(object sender, EventArgs e)
134			{
135			DialogResult result = CheatSaver.ShowDialog();
136			if (result != DialogResult.OK) { return; }
137
138
139			ICheatList2 list = new ICheatList2();
140			list.RVA = txtRVA.ToUInt32();
141			List<ICheatEntry2> cheats = new List<ICheatEntry2>();
142			foreach (ListViewItem li in lstCheats.Items)
143			{
144			cheats.Add(new ICheatEntry2(li.Text, Convert.ToUInt32(li.SubItems[1].Text, 16), Convert.ToUInt32(li.SubItems[2].Text, 16)));
145			}
146
147			list.Cheats = cheats;
148
149			try
150			{
151			using (FileStream fs = new FileStream(CheatSaver.FileName, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
152			{
153			try
154			{
155			fs.Seek(0, SeekOrigin.Begin);
156			BinaryFormatter bin = new BinaryFormatter();
157			bin.Serialize(fs, list);
158			}
159			catch (Exception ex)
160			{
161			gLog.Error.WriteLine("Failed to save file: {0}", CheatSaver.FileName);
162			gLog.Verbose.Error.WriteLine(ex.ToString());
163			MessageBox.Show(string.Format("Failed to save: '{0}'", new FileInfo(CheatSaver.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Error);
164			return;
165			}
166			}
167			MessageBox.Show(string.Format("Successfully saved file: '{0}'", new FileInfo(CheatSaver.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Information);
168			}
169			catch (Exception ex)
170			{
171			gLog.Error.WriteLine("Failed to save file: {0}", CheatSaver.FileName);
172			gLog.Verbose.Error.WriteLine(ex.ToString());
173			MessageBox.Show(string.Format("Failed to save: '{0}'", new FileInfo(CheatSaver.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Error);
174			}
175			}
176
177			private void btnLoad_Click(object sender, EventArgs e)
178			{
179			DialogResult result = CheatLoader.ShowDialog();
180			if (result != DialogResult.OK) { return; }
181			try
182			{
183			using (FileStream fs = new FileStream(CheatLoader.FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
184			{
185			try
186			{
187			ICheatList2 list = new ICheatList2();
188			BinaryFormatter bin = new BinaryFormatter();
189			try
190			{
191			fs.Seek(0, SeekOrigin.Begin);
192			var t_list = (ICheatList2)bin.Deserialize(fs);
193			list = t_list;
194			}
195			catch (Exception)
196			{
197			fs.Seek(0, SeekOrigin.Begin);
198			var t_list = (ICheatList)bin.Deserialize(fs);
199			list = new ICheatList2(t_list);
200			}
201
202			txtRVA.Value = list.RVA;
203			if (lstCheats.Items.Count > 0)
204			{
205			result = MessageBox.Show("Clear existing Cheats?", "", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button3);
206			if (result == System.Windows.Forms.DialogResult.Cancel)
207			{
208			// assume abort of load
209			gLog.Warn.WriteLine("Abored processing of file (by user request): {0}", CheatLoader.FileName);
210			fs.Close();
211			return;
212			}
213			if (result == DialogResult.Yes)
214			{
215			lstCheats.Items.Clear();
216			}
217			}
218			foreach (var cheat in list.Cheats)
219			{
220			ListViewItem li = new ListViewItem(cheat.CheatName);
221			li.SubItems.Add(new ListViewItem.ListViewSubItem(li, string.Format("0x{0:x8}", cheat.CheatAddress)));
222			uint physical = cheat.CheatAddress + list.RVA;
223			li.SubItems.Add(new ListViewItem.ListViewSubItem(li, string.Format("0x{0:x8}", physical)));
224			lstCheats.Items.Add(li);
225			}
226			btnRefresh.PerformClick(); // do any needed refreshing
227			}
228			catch (Exception ex)
229			{
230			gLog.Error.WriteLine("Failed to load file: {0}", CheatLoader.FileName);
231			gLog.Verbose.Error.WriteLine(ex.ToString());
232			MessageBox.Show(string.Format("Failed to open: '{0}'", new FileInfo(CheatLoader.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Error);
233			return;
234			}
235			}
236			//MessageBox.Show(string.Format("Successfully opened file: '{0}'", new FileInfo(CheatLoader.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Information);
237			}
238			catch (Exception ex)
239			{
240			gLog.Error.WriteLine("Failed to load file: {0}", CheatLoader.FileName);
241			gLog.Verbose.Error.WriteLine(ex.ToString());
242			MessageBox.Show(string.Format("Failed to open: '{0}'", new FileInfo(CheatLoader.FileName).Name), "", MessageBoxButtons.OK, MessageBoxIcon.Error);
243			}
244			ResizeColumns();
245			}
246
247			private void btnRefresh_Click(object sender, EventArgs e)
248			{
249			int index = 0;
250			foreach (ListViewItem li in lstCheats.Items)
251			{
252			string name = li.Text;
253			string address = li.SubItems[1].Text;
254			uint physical = Convert.ToUInt32(address, 16) + txtRVA.ToUInt32();
255			li.SubItems[2].Text = string.Format("0x{0:x8}", physical);
256			lstCheats.Items[index] = li;
257			index++;
258			}
259			ResizeColumns();
260			}
261			private void btnCopyAll_Click(object sender, EventArgs e)
262			{
263			ICheatList2 list = new ICheatList2();
264			list.RVA = txtRVA.ToUInt32();
265			List<ICheatEntry2> cheats = new List<ICheatEntry2>();
266			foreach (ListViewItem li in lstCheats.Items)
267			{
268			cheats.Add(new ICheatEntry2(li.Text, Convert.ToUInt32(li.SubItems[1].Text, 16), Convert.ToUInt32(li.SubItems[2].Text, 16)));
269			}
270			list.Cheats = cheats;
271			StringBuilder builder = new StringBuilder();
272			builder.AppendFormat("RVA: 0x{0:x8}", list.RVA);
273			builder.AppendLine();
274			foreach (ColumnHeader t in lstCheats.Columns)
275			{
276			builder.AppendFormat("{0}:\t\t", t.Text);
277			}
278			builder.AppendLine();
279			foreach (var cheat in list.Cheats)
280			{
281			builder.AppendFormat("{0}\t\t0x{1:x8}\t\t0x{2:x8}", cheat.CheatName, cheat.CheatAddress, cheat.PhysicalAddress);
282			builder.AppendLine();
283			}
284			Clipboard.SetText(builder.ToString());
285
286			}
287			private void RVACalculatorDockControl_Shown(object sender, EventArgs e)
288			{
289			//const int t = 100;
290			////txtRVA.SuspendLayout();
291			//logger.Debug.WriteLine("txtRva.Width={0}", txtRVA.Width);
292			//logger.Debug.WriteLine("increasing txtRva.Width to {0}", txtRVA.Width + t);
293			//txtRVA.Width = txtRVA.Width + t;
294			//logger.Debug.WriteLine("txtRva.Width={0}", txtRVA.Width);
295			////txtRVA.ResumeLayout();
296			}
297
298			[Serializable]
299			private struct ICheatEntry
300			{
301			public ICheatEntry(string name, uint address)
302			{
303			CheatName = name;
304			CheatAddress = address;
305			}
306			public string CheatName;
307			public uint CheatAddress;
308			}
309			[Serializable]
310			private struct ICheatEntry2
311			{
312			public ICheatEntry2(string name, uint address, uint physical)
313			{
314			CheatName = name;
315			CheatAddress = address;
316			PhysicalAddress = physical;
317			}
318			public string CheatName;
319			public uint CheatAddress;
320			public uint PhysicalAddress;
321			}
322			[Serializable]
323			private struct ICheatList
324			{
325			public ICheatList(ICheatList2 t)
326			{
327			RVA = t.RVA;
328			List<ICheatEntry> cheats = new List<ICheatEntry>();
329			t.Cheats.ForEach(c => cheats.Add(new ICheatEntry(c.CheatName,c.CheatAddress)));
330			Cheats = cheats;
331			}
332			public ICheatList(uint rva, List<ICheatEntry> cheats)
333			{
334			RVA = rva;
335			Cheats = cheats;
336			}
337			public uint RVA;
338			public List<ICheatEntry> Cheats;
339			}
340			[Serializable]
341			private struct ICheatList2
342			{
343			public ICheatList2(ICheatList t)
344			{
345			RVA = t.RVA;
346			List<ICheatEntry2> cheats = new List<ICheatEntry2>();
347			t.Cheats.ForEach(c => cheats.Add(new ICheatEntry2(c.CheatName, c.CheatAddress, c.CheatAddress)));
348			Cheats = cheats;
349			}
350			public ICheatList2(uint rva, List<ICheatEntry2> cheats)
351			{
352			RVA = rva;
353			Cheats = cheats;
354			}
355			public uint RVA;
356			public List<ICheatEntry2> Cheats;
357			}
358
359			private void txtRVA_ValueChanged(object sender, ValueChangedEventArgs e)
360			{
361			btnRefresh.PerformClick();
362			}
363
364
365			}
366			}