Spring – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 using System;
2 using System.ComponentModel;
3 using System.IO;
4 using System.Threading.Tasks;
5 using System.Windows.Forms;
6 using Spring.Properties;
7 using Spring.Serialization;
8 using Spring.Serialization.Combos;
9 using Spring.Utilities;
10 using Spring.Utilities.Collections;
11 using SpringCombos;
12  
13 namespace Spring.Editing
14 {
15 public partial class EditorForm : Form
16 {
17 #region Public Events & Delegates
18  
19 public event EventHandler<EditEventArgs> Edited;
20  
21 #endregion
22  
23 #region Public Enums, Properties and Fields
24  
25 public static Random Random { get; set; }
26  
27 public Configuration.Configuration Configuration { get; }
28  
29 public IndexedList<Combos> History { get; set; }
30  
31 #endregion
32  
33 #region Private Delegates, Events, Enums, Properties, Indexers and Fields
34  
35 private Combos Combos { get; set; }
36  
37 #endregion
38  
39 #region Constructors, Destructors and Finalizers
40  
41 public EditorForm()
42 {
43 InitializeComponent();
44 Utilities.WindowState.FormTracker.Track(this);
45  
46 Random = new Random();
47 History = new IndexedList<Combos>();
48  
49 Edited += EditorForm_Edited;
50 }
51  
52 public EditorForm(Combos chargeCombos) : this()
53 {
54 if (chargeCombos == null)
55 {
56 Combos = new Combos();
57  
58 return;
59 }
60  
61 Combos = chargeCombos;
62 }
63  
64 public EditorForm(Configuration.Configuration springConfiguration, Combos chargeCombos) : this(
65 chargeCombos) =>
66 Configuration = springConfiguration;
67  
68 /// <summary>
69 /// Clean up any resources being used.
70 /// </summary>
71 /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
72 protected override void Dispose(bool disposing)
73 {
74 if (disposing && components != null)
75 {
76 // Dispose event handlers.
77 Edited -= EditorForm_Edited;
78  
79 components.Dispose();
80 }
81  
82 base.Dispose(disposing);
83 }
84  
85 #endregion
86  
87 #region Event Handlers
88  
89 private async void InfinityToolStripMenuItem_Click(object sender, EventArgs e)
90 {
91 Combos.ComboRepeat = 0;
92  
93 await UpdateCombos(EditType.Transform);
94 }
95  
96 private async void RedoToolStripMenuItem_Click(object sender, EventArgs e)
97 {
98 editorBox.TextChanged -= EditorBox_TextChanged;
99  
100 Combos = History.Forward;
101  
102 await UpdateCombos(EditType.History);
103  
104 editorBox.TextChanged += EditorBox_TextChanged;
105 }
106  
107 private async void UndoToolStripMenuItem_Click(object sender, EventArgs e)
108 {
109 editorBox.TextChanged -= EditorBox_TextChanged;
110  
111 Combos = History.Back;
112  
113 await UpdateCombos(EditType.History);
114  
115 editorBox.TextChanged += EditorBox_TextChanged;
116 }
117  
118 private async void RepeatsToolStripTextBox_TextChanged(object sender, EventArgs e)
119 {
120 var toolStripTextBox = (ToolStripTextBox) sender;
121  
122 if (!int.TryParse(toolStripTextBox.Text, out var repeatCounts) ||
123 repeatCounts < 0)
124 {
125 return;
126 }
127  
128 Combos.ComboRepeat = repeatCounts;
129  
130 await UpdateCombos(EditType.Transform);
131 }
132  
133 private void EditorBox_MouseUp(object sender, MouseEventArgs e)
134 {
135 var textBox = (TextBox) sender;
136  
137 textBox.Focus();
138 }
139  
140 private void EditorBox_MouseDown(object sender, MouseEventArgs e)
141 {
142 var textBox = (TextBox) sender;
143  
144 textBox.Focus();
145 }
146  
147 private async void EditorBox_KeyUp(object sender, KeyEventArgs e)
148 {
149 if (e.KeyCode != Keys.Back)
150 {
151 return;
152 }
153  
154 var textBox = (TextBox) sender;
155  
156 if (string.IsNullOrEmpty(textBox.SelectedText))
157 {
158 return;
159 }
160  
161 textBox.SelectedText = string.Empty;
162  
163 await UpdateCombos(EditType.Edited);
164 }
165  
166 private async void FuzzToolStripMenuItem_TextChanged(object sender, EventArgs e)
167 {
168 var fuzzAdjustToolStripTextBox = (ToolStripTextBox) sender;
169  
170 if (!int.TryParse(fuzzAdjustToolStripTextBox.Text, out var adjustFuzz) ||
171 adjustFuzz < 0)
172 {
173 return;
174 }
175  
176 foreach (var combo in Combos.Combo)
177 {
178 switch (combo)
179 {
180 case PauseCombo pauseCombo:
181 pauseCombo.Fuzz = Random.Next(0, adjustFuzz);
182  
183 break;
184 }
185 }
186  
187 await UpdateCombos(EditType.Transform);
188 }
189  
190 private async void MouseRemoveToolStripMenuItem_Click(object sender, EventArgs e)
191 {
192 RemoveCombo<MouseCombo>(sender, e);
193 await UpdateCombos(EditType.Transform);
194 }
195  
196 private void RemoveCombo<T>(object sender, EventArgs e)
197 {
198 var localSpringCombos = new Combo[Combos.Combo.Count];
199  
200 Combos.Combo.CopyTo(localSpringCombos);
201  
202 foreach (var combo in localSpringCombos)
203 {
204 switch (combo)
205 {
206 case T _:
207 Combos.Combo.Remove(combo);
208  
209 break;
210 }
211 }
212 }
213  
214 private async void KeyRemoveToolStripMenuItem_Click(object sender, EventArgs e)
215 {
216 RemoveCombo<KeyboardCombo>(sender, e);
217 await UpdateCombos(EditType.Transform);
218 }
219  
220 private async void PauseRemoveToolStripMenuItem_Click(object sender, EventArgs e)
221 {
222 RemoveCombo<PauseCombo>(sender, e);
223 await UpdateCombos(EditType.Transform);
224 }
225  
226 private async void EquateToolStripTextBox_TextChanged(object sender, EventArgs e)
227 {
228 if (!int.TryParse(equateToolStripTextBox.Text, out var pauseValue))
229 {
230 return;
231 }
232  
233 foreach (var combo in Combos.Combo)
234 {
235 switch (combo)
236 {
237 case PauseCombo pauseCombo:
238 pauseCombo.TimeSpan = TimeSpan.FromMilliseconds(pauseValue);
239  
240 break;
241 }
242 }
243  
244 await UpdateCombos(EditType.Transform);
245 }
246  
247 private async void ReverseToolStripMenuItem_Click(object sender, EventArgs e)
248 {
249 Combos.Combo.Reverse();
250  
251 await UpdateCombos(EditType.Transform);
252 }
253  
254 private void EditorForm_Edited(object sender, EditEventArgs e)
255 {
256 switch (e)
257 {
258 case EditSuccessEventArgs editSuccessEventArgs:
259  
260 // Do not update the text box, instead just update the object or print out any errors.
261 this.InvokeIfRequired(form => { form.editorBox.Text = editSuccessEventArgs.Text; });
262 Combos = editSuccessEventArgs.Combos;
263  
264 switch (editSuccessEventArgs.Type)
265 {
266 case EditType.History:
267 case EditType.Load:
268 case EditType.Save:
269 break;
270  
271 case EditType.Edited:
272 case EditType.Transform:
273 History.Add(Combos);
274  
275 break;
276  
277 default:
278 throw new ArgumentOutOfRangeException();
279 }
280  
281 $"History Count: {History.Count}".ToDebugConsole();
282  
283 break;
284  
285 case EditFailureEventArgs editFailureEventArgs:
286 break;
287 }
288 }
289  
290 private async void SaveFileDialog1_FileOk(object sender, CancelEventArgs e)
291 {
292 switch (await Combos.Serialize(saveFileDialog1.FileName))
293 {
294 case SerializationSuccess<Combos> serializationSuccess:
295 toolStripStatusLabel1.Text = $"{Strings.Combos_wrote_successfully}";
296  
297 Edited?.Invoke(this,
298 new EditSuccessEventArgs(EditType.Save, saveFileDialog1.FileName, serializationSuccess));
299  
300 break;
301  
302 case SerializationFailure serializationFailed:
303 toolStripStatusLabel1.Text =
304 $"{Strings.Failed_to_write_combos}: {serializationFailed.Exception.Message}";
305  
306 Edited?.Invoke(this, new EditFailureEventArgs(serializationFailed));
307 ;
308  
309 break;
310 }
311 }
312  
313 private async void OpenFileDialog1_FileOk(object sender, CancelEventArgs e)
314 {
315 var file = new FileInfo(openFileDialog1.FileName);
316  
317 switch (await ComboSerialization.Deserialize(file, 0))
318 {
319 case SerializationSuccess<Combos> serializationSuccess:
320 toolStripStatusLabel1.Text = $"{Strings.Combos_read_successfully}";
321  
322 Edited?.Invoke(this,
323 new EditSuccessEventArgs(EditType.Load, openFileDialog1.FileName, serializationSuccess));
324  
325 break;
326  
327 case SerializationFailure deserializationFailure:
328 toolStripStatusLabel1.Text =
329 $"{Strings.Failed_to_read_combos}: {deserializationFailure.Exception.Message}";
330  
331 Edited?.Invoke(this, new EditFailureEventArgs(deserializationFailure));
332  
333 break;
334 }
335 }
336  
337 private void ImportToolStripMenuItem_Click(object sender, EventArgs e)
338 {
339 openFileDialog1.ShowDialog();
340 }
341  
342 private void ExportToolStripMenuItem_Click(object sender, EventArgs e)
343 {
344 saveFileDialog1.ShowDialog();
345 }
346  
347 private async void EditorBox_TextChanged(object sender, EventArgs e)
348 {
349 var textBox = (TextBox) sender;
350  
351 switch (await ComboSerialization.Deserialize(textBox.Text))
352 {
353 case SerializationSuccess<Combos> serializationSuccess:
354 toolStripStatusLabel1.Text = $"{Strings.Combos_wrote_successfully}";
355  
356 Edited?.Invoke(this, new EditSuccessEventArgs(EditType.Edited, serializationSuccess));
357 Combos = serializationSuccess.Result;
358  
359 break;
360  
361 case SerializationFailure deserializationFailure:
362 toolStripStatusLabel1.Text =
363 $"{Strings.Failed_to_write_combos}: {deserializationFailure.Exception.Message}";
364  
365 Edited?.Invoke(this, new EditFailureEventArgs(deserializationFailure));
366  
367 break;
368 }
369 }
370  
371 private async void EditorForm_Shown(object sender, EventArgs e)
372 {
373 switch (await Combos.Serialize())
374 {
375 case SerializationSuccess<Combos> serializationSuccess:
376 // Set editor text.
377 this.InvokeIfRequired(form =>
378 {
379 form.editorBox.Text = serializationSuccess.Text;
380  
381 form.repeatsToolStripTextBox.Text = $"{serializationSuccess.Result.ComboRepeat}";
382  
383 form.fuzzToolStripTextBox.Text = $"{Configuration.Spring.Fuzz}";
384  
385 form.toolStripStatusLabel1.Text = $"{Strings.Combos_read_successfully}";
386 });
387  
388 break;
389  
390 case SerializationFailure serializationFailed:
391 this.InvokeIfRequired(form =>
392 {
393 form.toolStripStatusLabel1.Text =
394 $"{Strings.Failed_to_read_combos}: {serializationFailed.Exception.Message}";
395 });
396  
397 break;
398 }
399  
400 this.InvokeIfRequired(form =>
401 {
402 form.fuzzToolStripTextBox.TextChanged += FuzzToolStripMenuItem_TextChanged;
403 form.repeatsToolStripTextBox.TextChanged += RepeatsToolStripTextBox_TextChanged;
404 });
405 }
406  
407 private void EditorForm_Closing(object sender, FormClosingEventArgs e)
408 {
409 fuzzToolStripTextBox.TextChanged -= FuzzToolStripMenuItem_TextChanged;
410 repeatsToolStripTextBox.TextChanged -= RepeatsToolStripTextBox_TextChanged;
411 }
412  
413 #endregion
414  
415 #region Private Methods
416  
417 private async Task UpdateCombos(EditType editType)
418 {
419 switch (await Combos.Serialize())
420 {
421 case SerializationSuccess<Combos> serializationSuccess:
422 editorBox.Text = serializationSuccess.Text;
423 Edited?.Invoke(this, new EditSuccessEventArgs(editType, serializationSuccess));
424 Combos = serializationSuccess.Result;
425  
426 break;
427  
428 case SerializationFailure serializationFailure:
429 toolStripStatusLabel1.Text = $"{Strings.Could_not_modify_combos}";
430  
431 break;
432 }
433 }
434  
435 #endregion
436 }
437 }