Spring – Diff between revs 1 and 2

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