Sfall-ScriptEditor

1
using System;
2
using System.Collections.Generic;
3
using System.Drawing;
4
using System.IO;
5
using System.Linq;
6
using System.Text;
7
using System.Windows.Forms;
8

9
using ScriptEditor.TextEditorUI;
10
using ScriptEditor.TextEditorUtilities;
11

12
namespace ScriptEditor
13
{
14
    public delegate void SendLineHandler(string msgLine);
15

16
    partial class MessageEditor : Form
17
    {
18
        private const int WM_SETREDRAW = 0x000B;
19

20
        [System.Runtime.InteropServices.DllImport("user32.dll")]
21
        public static extern int SendMessage(IntPtr hWnd, Int32 wMsg, bool wParam, Int32 lParam);
22

23
        public event SendLineHandler SendMsgLine;
24

25
        private List<string> linesMsg;
26
        private string msgPath;
27
        private bool isCancelEdit;
28
        private bool allow;
29

30
        private Color editColor;
31
        private bool editAllowed = true;
32
        private bool isEditMode = false;
33
        private bool shiftKeyDown = false;
34

35
        private const string COMMENT = "#";
36
        private const string pcMarker = "\u25CF ";
37

38
        private Color pcColor = Color.FromArgb(0, 0, 220);
39
        private Color cmColor;
40

41
        private Encoding enc = Settings.EncCodePage;
42

43
        private TabInfo associateTab;
44
        private Form scriptForm;
45

46
        internal bool closeOnSend = false;
47

48
        private cell SelectLine = new cell();
49

50
        private struct cell
51
        {
52
            public int row;
53
            public int col;
54
        }
55

56
        public enum CommentColor { LightYellow, PaleGreen, Lavender }
57

58
        //List<Entry> rowsEntry = new List<Entry>();
59
        //List<List<Entry>> rowsUndo = new List<Entry>();
60

61
        private void RowsClear()
62
        {
63
            dgvMessage.Rows.Clear();
64
            //rowsEntry.Clear();
65
        }
66

67
        #region Entry DGV
68
        private class Entry
69
        {
70
            static private bool wrapLine = false;
71

72
            public string msgLine = string.Empty;
73
            public string msglip = string.Empty;
74
            public string msgText = string.Empty;
75
            public string description = string.Empty;
76

77
            public bool pcMark = false;
78
            public bool commentLine = false;
79

80
            public int tabCount = 1;
81

82
            static public bool IsWrap
83
            {
84
                get { return wrapLine; }
85
            }
86

87
            public Entry() { }
88

89
            public Entry(string line)
90
            {
91
                //wrapLine = false;
92
                if (line.Length == 0) return;
93
                if (line.TrimStart().StartsWith(COMMENT)) {
94
                    msgLine = "-";
95
                    msgText = line;
96
                    commentLine = true;
97
                } else {
98
                    string[] splitLine = line.Split(new char[] {'}'}, 4);
99
                    if (splitLine.Length == 0) return; // msg bad
100

101
                    wrapLine = splitLine.Length == 3;
102

103
                    if (splitLine[0].StartsWith("\t")) {
104
                        tabCount = splitLine[0].Length;
105
                        splitLine[0] = splitLine[0].TrimStart('\t');
106
                        tabCount -= splitLine[0].Length;
107
                        pcMark = true;
108
                    }
109
                    int z = splitLine[0].IndexOf('{');
110
                    msgLine = splitLine[0].Substring(z + 1); // номер строки
111

112
                    z = splitLine[1].IndexOf('{');
113
                    msglip = splitLine[1].Substring(z + 1);
114

115
                    z = splitLine[2].IndexOf('{');
116
                    msgText = splitLine[2].Substring(z + 1);
117
                    if (splitLine.Length > 3 && splitLine[3].Length > 0)
118
                        description = splitLine[3].TrimEnd();
119
                }
120
            }
121

122
            public void Append(string line)
123
            {
124
                int end = line.IndexOf('}');
125
                wrapLine = (end == -1);
126
                if (wrapLine) {
127
                    msgText += Environment.NewLine + line;
128
                } else {
129
                    msgText += Environment.NewLine + line.Remove(end);
130
                    description = line.Substring(end + 1).TrimEnd();
131
                }
132
            }
133

134
            public string ToString(out bool prev)
135
            {
136
                prev = false;
137
                int result;
138
                if (int.TryParse(msgLine, out result)) {
139
                    string tab = (pcMark) ? new String('\t', tabCount) : String.Empty;
140
                    return (tab + "{" + msgLine + "}{" + msglip + "}{" + msgText + "}" + description);
141
                }
142
                return (msgText + description);
143
            }
144
        }
145
        #endregion
146

147
        private void AddRow(Entry e)
148
        {
149
            //if (dgvMessage.VirtualMode) {
150
            //    rowsEntry.Add(e);
151
            //    return;
152
            //}
153

154
            string message = (e.pcMark) ? pcMarker + e.msgText : e.msgText;
155
            dgvMessage.Rows.Add(e.msgLine, message, e.msglip);
156
            int row = dgvMessage.Rows.Count - 1;
157
            dgvMessage.Rows[row].Cells[0].Tag = e;
158
            dgvMessage.Rows[row].Cells[1].ToolTipText = e.description.Trim();
159

160
            if (e.commentLine)
161
                MarkCommentLine(row);
162
            else if (e.pcMark)
163
                dgvMessage.Rows[row].Cells[1].Style.ForeColor = pcColor;
164
        }
165

166
        private void InsertRow(int i, Entry e)
167
        {
168
            if (i >= dgvMessage.Rows.Count) {
169
                SelectLine.row = dgvMessage.Rows.Count;
170
                AddRow(e);
171
            } else {
172
                string message = (e.pcMark) ? pcMarker + e.msgText : e.msgText;
173
                dgvMessage.Rows.Insert(i, e.msgLine, message, e.msglip);
174
                dgvMessage.Rows[i].Cells[0].Tag = e;
175
            }
176
            if (e.commentLine)
177
                MarkCommentLine(i);
178
        }
179

180
        private void MarkCommentLine(int row)
181
        {
182
            if (!Settings.msgHighlightComment)
183
                return;
184

185
            foreach (DataGridViewCell cell in dgvMessage.Rows[row].Cells)
186
                cell.Style.BackColor = cmColor;
187
        }
188

189
        private void HighlightingCommentUpdate()
190
        {
191
            Color clr = (Settings.msgHighlightComment) ? cmColor : dgvMessage.RowsDefaultCellStyle.BackColor;
192
            for (int row = 0; row < dgvMessage.Rows.Count; row++)
193
            {
194
                Entry ent = (Entry)dgvMessage.Rows[row].Cells[0].Tag;
195
                if (ent.commentLine) {
196
                    for (int col = 0; col < dgvMessage.Rows[row].Cells.Count; col++)
197
                        dgvMessage.Rows[row].Cells[col].Style.BackColor = clr;
198
                }
199
            }
200
        }
201

202
        private void SetCommentColor()
203
        {
204
            Color lineColumnColor;
205
            switch ((CommentColor)Settings.msgHighlightColor)
206
            {
207
                case CommentColor.LightYellow:
208
                default:
209
                    cmColor = Color.FromArgb(255, 255, 200);
210
                    lineColumnColor = Color.LightYellow;
211
                break;
212
                case CommentColor.Lavender:
213
                    cmColor = Color.Lavender;
214
                    lineColumnColor = Color.FromArgb(240, 240, 250);
215
                    break;
216
                case CommentColor.PaleGreen:
217
                    cmColor = Color.FromArgb(195, 255, 195);
218
                    lineColumnColor = Color.FromArgb(215, 255, 215);
219
                    break;
220
            }
221
            dgvMessage.Columns[0].DefaultCellStyle.BackColor = lineColumnColor;
222
        }
223

224
        #region Initial form
225
        // call from testing dialog tools and node code editor
226
        public static MessageEditor MessageEditorInit(string msgPath, int line, TabInfo tab = null, bool sendState = false)
227
        {
228
            MessageEditor msgEdit = new MessageEditor(msgPath, tab);
229

230
            for (int i = 0; i < msgEdit.dgvMessage.RowCount; i++)
231
            {
232
                int number;
233
                if (int.TryParse(msgEdit.dgvMessage.Rows[i].Cells[0].Value.ToString(), out number))
234
                    if (number == line) {
235
                        msgEdit.dgvMessage.Rows[i].Cells[1].Selected = true;
236
                        msgEdit.dgvMessage.FirstDisplayedScrollingRowIndex = (i <= 5) ? i : i - 5;
237
                        break;
238
                    }
239
            }
240
            msgEdit.SendStripButton.Enabled = sendState;
241

242
            return msgEdit;
243
        }
244

245
        // call from main script editor
246
        public static MessageEditor MessageEditorInit(TabInfo tab, Form frm)
247
        {
248
            string msgPath = null;
249
            if (tab != null) {
250
                if (!MessageFile.GetAssociatePath(tab, true, out msgPath))
251
                    return null;
252

253
                tab.msgFilePath = msgPath;
254
            }
255

256
            // Show form
257
            MessageEditor msgEdit = new MessageEditor(msgPath, tab);
258
            msgEdit.scriptForm = frm;
259
            if (tab != null)
260
                msgEdit.alwaysOnTopToolStripMenuItem.Checked = true;
261
            msgEdit.Show();
262
            //if (Settings.autoOpenMsgs && msgEdit.scrptEditor.msgAutoOpenEditorStripMenuItem.Checked)
263
            //    msgEdit.WindowState = FormWindowState.Minimized;
264

265
            return msgEdit;
266
        }
267

268
        // for open custom message file
269
        public static MessageEditor MessageEditorOpen(string msgPath, Form frm)
270
        {
271
            if (msgPath == null)
272
                MessageBox.Show("No output path selected.", "Error");
273

274
            // Show form
275
            MessageEditor msgEdit = new MessageEditor(msgPath, null);
276
            msgEdit.scriptForm = frm;
277
            msgEdit.WindowState = FormWindowState.Maximized;
278
            frm.TopMost = false;
279
            msgEdit.Show();
280

281
            return msgEdit;
282
        }
283
        #endregion
284

285
        #region Constructor
286
        public MessageEditor(string msgfile) : this (msgfile, null)
287
        {
288
            SendStripButton.Enabled = false;
289
        }
290

291
        private MessageEditor(string msg, TabInfo ti)
292
        {
293
            InitializeComponent();
294

295
            //dgvMessage.DoubleBuffered(true);
296
            //dgvMessage.VirtualMode = true;
297

298
            dgvMessage.Columns[2].Visible = Settings.msgLipColumn;
299
            showLIPColumnToolStripMenuItem.Checked = Settings.msgLipColumn;
300

301
            FontSizeComboBox.SelectedIndex = Settings.msgFontSize;
302
            if (Settings.msgFontSize != 0)
303
                FontSizeChanged(null, null);
304
            FontSizeComboBox.SelectedIndexChanged += FontSizeChanged;
305

306
            ColorComboBox.SelectedIndex = Settings.msgHighlightColor;
307
            HighlightingCommToolStripMenuItem.Checked = Settings.msgHighlightComment;
308

309
            if (Settings.encoding == (byte)EncodingType.OEM866)
310
                encodingTextDOSToolStripMenuItem.Checked = true;
311

312
            StripComboBox.SelectedIndex = 2;
313
            if (!Settings.msgLipColumn) {
314
                dgvMessage.Columns[2].Visible = false;
315
                showLIPColumnToolStripMenuItem.Checked = false;
316
            }
317

318
            UpdateRecentList();
319

320
            msgPath = msg;
321
            if (msgPath != null)
322
                ReadMsgFile();
323
            else {
324
                this.Text = "Empty" + this.Tag;
325
                AddRow(new Entry());
326
                linesMsg = new List<string>();
327
            }
328

329
            associateTab = ti;
330
            if (associateTab != null)
331
                MessageFile.ParseMessages(associateTab, linesMsg.ToArray());
332
        }
333
        #endregion
334

335
        #region Load/Save Msg File
336
        private void ReadMsgFile()
337
        {
338
            linesMsg = new List<string>(File.ReadAllLines(msgPath, enc));
339

340
            ProgressBarForm progress = null;
341
            if (linesMsg.Count > 250)
342
                progress = new ProgressBarForm(this, linesMsg.Count);
343

344
            dgvMessage.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
345
            SendMessage(dgvMessage.Handle, WM_SETREDRAW, false, 0);
346

347
            for (int i = 0; i < linesMsg.Count; i++)
348
            {
349
                Entry entry;
350
                try {
351
                    entry = new Entry(linesMsg[i]);
352
                } catch (Exception) {
353
                    MessageBox.Show("Message file is bad!\nLine Error: " + i.ToString());
354
                    break;
355
                }
356
                while (Entry.IsWrap && ++i < linesMsg.Count) entry.Append(linesMsg[i]);
357

358
                AddRow(entry);
359
                if (progress != null) progress.SetProgress = i;
360
            }
361
            //if (dgvMessage.VirtualMode) dgvMessage.RowCount = rowsEntry.Count;
362

363
            SendMessage(dgvMessage.Handle, WM_SETREDRAW, true, 0);
364
            dgvMessage.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders;
365

366
            if (progress != null)
367
                progress.Dispose();
368

369
            this.Text = Path.GetFileName(msgPath) + this.Tag;
370
            groupBox.Text = msgPath;
371
            msgSaveButton.Enabled = false;
372
        }
373

374
        private void SaveFileMsg()
375
        {
376
            bool prevLine;
377
            bool replaceX = (enc.CodePage == 866);
378
            dgvMessage.EndEdit();
379
            linesMsg.Clear();
380
            for (int i = 0; i < dgvMessage.Rows.Count; i++)
381
            {
382
                Entry entries = (Entry)dgvMessage.Rows[i].Cells[0].Tag;
383
                string line = entries.ToString(out prevLine);
384

385
                if (replaceX)
386
                    line = line.Replace('\u0425', '\u0058'); //Replacement of Russian letter "X", to English letter
387

388
                linesMsg.Add(line);
389

390
                if (prevLine)
391
                    linesMsg[i - 1] = linesMsg[i - 1].TrimEnd('}');
392

393
                foreach (DataGridViewCell cells in dgvMessage.Rows[i].Cells)
394
                {
395
                    switch (cells.ColumnIndex) {
396
                        case 0:
397
                            cells.Style.ForeColor = Color.Chocolate;
398
                            break;
399
                        case 2:
400
                            cells.Style.ForeColor = Color.Gray;
401
                            break;
402
                        default:
403
                            if (entries.pcMark)
404
                                cells.Style.ForeColor = pcColor;
405
                            else
406
                                cells.Style.ForeColor = dgvMessage.RowsDefaultCellStyle.ForeColor;
407
                            break;
408
                    }
409
                }
410
            }
411
            File.WriteAllLines(msgPath, linesMsg.ToArray(), enc);
412
            msgSaveButton.Enabled = false;
413

414
            if (associateTab != null)
415
                MessageFile.ParseMessages(associateTab, linesMsg.ToArray());
416
        }
417
        #endregion
418

419
        private void dgvMessage_CellValueChanged(object sender, DataGridViewCellEventArgs e)
420
        {
421
            if (e.RowIndex == -1 || e.ColumnIndex == -1 || isCancelEdit) return;
422

423
            DataGridViewCell cell = dgvMessage.Rows[e.RowIndex].Cells[e.ColumnIndex];
424
            Entry entry = (Entry)dgvMessage.Rows[e.RowIndex].Cells[0].Tag;
425

426
            string valCell = (string)cell.Value;
427
            if (valCell == null) valCell = string.Empty;
428

429
            switch (e.ColumnIndex) {
430
                case 0: // line
431
                    int result;
432
                    if (!int.TryParse(valCell, out result)) {
433
                        MessageBox.Show("Line must contain only numbers.", "Line Error");
434
                        isCancelEdit = true;
435
                        cell.Value = entry.msgLine;
436
                    } else
437
                        entry.msgLine = valCell;
438
                    break;
439
                case 1: // message
440
                    if (valCell.IndexOfAny(new char[] { '{', '}' }) != -1) {
441
                        isCancelEdit = true;
442
                        valCell = entry.msgText; // cancel
443
                    } else {
444
                        if (valCell.Length > 0 && valCell.TrimStart().StartsWith(pcMarker[0].ToString())) {
445
                            entry.msgText = valCell.Remove(0, 1).TrimStart(); // удалить лишний маркер
446
                        } else {
447
                            entry.msgText = valCell;
448
                        }
449
                    }
450
                    // добавить/удалить маркер для отображения в таблице
451
                    if (valCell.Length > 0) {
452
                        if (entry.pcMark) {
453
                            if (!valCell.TrimStart().StartsWith(pcMarker)) {
454
                                valCell = pcMarker + valCell; // добавить
455
                            }
456
                        } else if (valCell.TrimStart().StartsWith(pcMarker)) {
457
                                valCell = entry.msgText;      // удалить
458
                        }
459
                    }
460
                    cell.Value = valCell;
461
                    break;
462
                case 2: // lipfile
463
                    if (valCell.IndexOfAny(new char[] { '{', '}' }) != -1) {
464
                        isCancelEdit = true;
465
                        cell.Value = entry.msglip;
466
                    } else
467
                        entry.msglip = valCell;
468
                    break;
469
            }
470
            if (!isCancelEdit) {
471
                dgvMessage.Rows[e.RowIndex].Cells[e.ColumnIndex].Style.ForeColor = Color.Red;
472
                msgSaveButton.Enabled = true;
473
            }
474
            isCancelEdit = false;
475
        }
476

477
        private void dgvMessage_SelectionChanged(object sender, EventArgs e)
478
        {
479
            if (allow) {
480
                SelectLine.row = (dgvMessage.CurrentRow == null) ? 0 : dgvMessage.CurrentRow.Index;
481
                SelectLine.col = (dgvMessage.CurrentRow == null) ? 0 : dgvMessage.CurrentCell.ColumnIndex;
482
            } else
483
                allow = true;
484

485
            editAllowed = false;
486
        }
487

488
        private void SendStripButton_Click(object sender, EventArgs e)
489
        {
490
            if (SendMsgLine == null) return;
491

492
            string line = (string)dgvMessage.Rows[SelectLine.row].Cells[0].Value;
493
            int result;
494
            if (int.TryParse(line, out result)) {
495
                SendMsgLine(line);
496
                if (closeOnSend)
497
                    this.Close();
498
            }
499
        }
500

501
        private void NewStripButton_Click(object sender, EventArgs e)
502
        {
503
            RowsClear();
504

505
            AddRow(new Entry("# Look Name"));
506
            AddRow(new Entry("{100}{}{}"));
507
            AddRow(new Entry("# Description"));
508
            AddRow(new Entry("{101}{}{}"));
509

510
            this.Text = "unsaved.msg" + this.Tag;
511
            this.groupBox.Text = "Messages";
512

513
            linesMsg = new List<string>();
514
            msgPath = null;
515
            msgSaveButton.Enabled = false;
516
        }
517

518
        private void msgOpenButton_ButtonClick(object sender, EventArgs e)
519
        {
520
            string path = msgPath;
521
            if (path == null && Settings.outputDir != null)
522
                path = Path.GetFullPath(Path.Combine(Settings.outputDir, MessageFile.MessageTextSubPath));
523

524
            openFileDialog.InitialDirectory = Path.GetDirectoryName(path);
525
            if (openFileDialog.ShowDialog() == DialogResult.OK) {
526
                msgPath = openFileDialog.FileName;
527
                RowsClear();
528
                ReadMsgFile();
529
                if (Path.IsPathRooted(msgPath)) {
530
                    Settings.AddMsgRecentFile(msgPath);
531
                    UpdateRecentList();
532
                }
533
            }
534
        }
535

536
        private void msgSaveButton_ButtonClick(object sender, EventArgs e)
537
        {
538
            if (msgPath == null)
539
                SaveAsStripButton_Click(null, null);
540
            else
541
                SaveFileMsg();
542
        }
543

544
        private void SaveAsStripButton_Click(object sender, EventArgs e)
545
        {
546
            string path = msgPath;
547

548
            if (path == null && Settings.outputDir != null)
549
                path = Path.GetFullPath(Path.Combine(Settings.outputDir, MessageFile.MessageTextSubPath));
550

551
            saveFileDialog.InitialDirectory = Path.GetDirectoryName(path);
552
            saveFileDialog.FileName = Path.GetFileName(msgPath);
553
            if (saveFileDialog.ShowDialog() == DialogResult.OK) {
554
                msgPath = saveFileDialog.FileName;
555
                SaveFileMsg();
556
                this.Text = Path.GetFileName(msgPath) + this.Tag;
557
                groupBox.Text = msgPath;
558
                Settings.AddMsgRecentFile(msgPath);
559
                UpdateRecentList();
560
            }
561
        }
562

563
        private bool AddNewLine()
564
        {
565
            int Line = 0, nLine;
566
            bool _comm = false;
567
            bool isEdit = dgvMessage.IsCurrentCellInEditMode;
568

569
            for (int n = SelectLine.row; n >= 0; n--)
570
            {
571
                if (int.TryParse((string)dgvMessage.Rows[n].Cells[0].Value, out Line)) break;
572
                string val = (string)dgvMessage.Rows[n].Cells[1].Value;
573
                if (/*val != null &&*/ val.StartsWith("#")) _comm = true;
574
            }
575
            if (_comm) {
576
                Line = (int)Math.Round((decimal)Line / 10) * 10;
577
                Line += Convert.ToInt32(StripComboBox.Text);
578
            } else Line++;
579
            for (int n = 0; n < dgvMessage.Rows.Count; n++)
580
            {
581
                if (int.TryParse((string)dgvMessage.Rows[n].Cells[0].Value, out nLine)) {
582
                    if (Line == nLine) {
583
                        return false;
584
                    }
585
                }
586
            }
587

588
            dgvMessage.EndEdit();
589

590
            if ((string)dgvMessage.Rows[SelectLine.row].Cells[0].Value != string.Empty) SelectLine.row++;
591
            InsertRow(SelectLine.row, new Entry("{" + Line + "}{}{}"));
592
            msgSaveButton.Enabled = true;
593
            allow = false;
594
            try { dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].Selected = true; }
595
            catch { };
596

597
            if (isEdit)
598
                dgvMessage.BeginEdit(false);
599

600
            return true;
601
        }
602

603
        private void IncAddStripButton_Click(object sender, EventArgs e)
604
        {
605
            if (!AddNewLine()) System.Media.SystemSounds.Question.Play();
606
        }
607

608
        private void InsertEmptyStripButton_Click(object sender, EventArgs e)
609
        {
610
            if (sender != null && !shiftKeyDown)
611
                SelectLine.row++;
612

613
            InsertRow(SelectLine.row, new Entry(""));
614
            allow = false;
615

616
            if (sender == null || shiftKeyDown)
617
                SelectLine.row++;
618
            try { dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].Selected = true; }
619
            catch { };
620

621
            msgSaveButton.Enabled = true;
622
        }
623

624
        private void DeleteLineStripButton_Click(object sender, EventArgs e)
625
        {
626
            if (dgvMessage.Rows.Count <= 1) return;
627

628
            DataGridViewSelectedRowCollection selRows = dgvMessage.SelectedRows;
629
            if (selRows.Count > 0) {
630
                foreach (DataGridViewRow row in selRows)
631
                    dgvMessage.Rows.Remove(row);
632
                if (dgvMessage.RowCount == 0) AddRow(new Entry());
633
            } else {
634
                dgvMessage.Rows.RemoveAt(SelectLine.row);
635
                if (SelectLine.row >= dgvMessage.Rows.Count) SelectLine.row--;
636
            }
637
            msgSaveButton.Enabled = true;
638
        }
639

640
        private void InsertCommentStripButton_Click(object sender, EventArgs e)
641
        {
642
            if (dgvMessage.IsCurrentCellInEditMode || dgvMessage.MultiSelect)
643
                return;
644

645
            string comment = COMMENT;
646
            if ((string)dgvMessage.Rows[SelectLine.row].Cells[0].Value == String.Empty) {
647
                comment += dgvMessage.Rows[SelectLine.row].Cells[1].Value;
648
                dgvMessage.Rows.RemoveAt(SelectLine.row);
649
            } else
650
                SelectLine.row++;
651

652
            InsertRow(SelectLine.row, new Entry(comment));
653
            allow = false;
654
            try { dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].Selected = true; }
655
            catch { };
656
            msgSaveButton.Enabled = true;
657
        }
658

659
        #region Search function
660
        private void Finds(int rowStart, int colStart, int rev = 1)
661
        {
662
            string find_str = SearchStripTextBox.Text.Trim();
663
            if (find_str.Length == 0) {
664
                MessageBox.Show("Nothing found.");
665
                return;
666
            }
667

668
            cell findPosition = new cell();
669
            findPosition.col = -1;
670

671
            if (rev == -1 && rowStart == 0) rowStart = dgvMessage.RowCount - 1;
672

673
            for (int row = rowStart; row < dgvMessage.RowCount; row += rev)
674
            {
675
                if (row < 0) break;
676
                for (int col = colStart; col < dgvMessage.ColumnCount; col++)
677
                {
678
                    if (dgvMessage.Rows[row].Cells[col].Value == null)
679
                        continue;
680
                    string value = dgvMessage.Rows[row].Cells[col].Value.ToString();
681
                    if (value.IndexOf(find_str, 0, StringComparison.OrdinalIgnoreCase) != -1) {
682
                        findPosition.row = row;
683
                        findPosition.col = col;
684
                        break;
685
                    }
686
                }
687
                if (findPosition.col != 0) break;
688
                colStart = 0;
689
            }
690
            if (findPosition.col != 0) {
691
                dgvMessage.FirstDisplayedScrollingRowIndex = (findPosition.row <= 5) ? findPosition.row : findPosition.row - 5;
692
                dgvMessage.Rows[findPosition.row].Cells[findPosition.col].Selected = true;
693
            }
694

695
            if (findPosition.col == -1)
696
                System.Media.SystemSounds.Exclamation.Play();
697
            else {
698
                SelectLine = findPosition;
699
            }
700
        }
701

702
        private void Downbutton_Click(object sender, EventArgs e)
703
        {
704
            Finds(SelectLine.row, SelectLine.col + 1);
705
        }
706

707
        private void Upbutton_Click(object sender, EventArgs e)
708
        {
709
            Finds(SelectLine.row, SelectLine.col + 1, -1);
710
        }
711
        #endregion
712

713
        private void showLIPColumnToolStripMenuItem_Click(object sender, EventArgs e)
714
        {
715
            dgvMessage.Columns[2].Visible = showLIPColumnToolStripMenuItem.Checked;
716
            Settings.msgLipColumn = showLIPColumnToolStripMenuItem.Checked;
717
        }
718

719
        private void UpdateRecentList()
720
        {
721
            string[] items = Settings.GetMsgRecent();
722
            msgOpenButton.DropDownItems.Clear();
723
            for (int i = items.Length - 1; i >= 0; i--) {
724
                msgOpenButton.DropDownItems.Add(items[i], null, MsgRecentClick);
725
            }
726
        }
727

728
        private void MsgRecentClick(object sender, EventArgs e)
729
        {
730
            string rFile = ((ToolStripMenuItem)sender).Text;
731
            // Check recent file
732
            bool delete = false;
733
            if (File.Exists(rFile)) {
734
                msgPath = rFile;
735
                RowsClear();
736
                ReadMsgFile();
737
            } else if (MessageBox.Show("Message file not found.\n Delete this recent link?", "Warning", MessageBoxButtons.YesNo) == DialogResult.Yes)
738
                delete = true; // delete from recent list
739
            Settings.AddMsgRecentFile(rFile, delete);
740
            UpdateRecentList();
741
        }
742

743
        private void encodingTextDOSToolStripMenuItem_Click(object sender, EventArgs e)
744
        {
745
            enc = (encodingTextDOSToolStripMenuItem.Checked) ? Encoding.GetEncoding("cp866") : Encoding.Default;
746
            if (msgPath != null) {
747
                dgvMessage.SelectionChanged -= dgvMessage_SelectionChanged;
748

749
                RowsClear();
750
                ReadMsgFile();
751
                dgvMessage.FirstDisplayedScrollingRowIndex = (SelectLine.row <= 5) ? SelectLine.row : SelectLine.row - 5;
752
                if (SelectLine.row > 0 || SelectLine.col > 0)
753
                    dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].Selected = true;
754

755
                dgvMessage.SelectionChanged += dgvMessage_SelectionChanged;
756
            }
757
        }
758

759
        private void MessageEditor_KeyDown(object sender, KeyEventArgs e)
760
        {
761
            if (e.KeyCode == Keys.ShiftKey) {
762
                shiftKeyDown = true;
763
            }
764
            else if (e.KeyCode == Keys.Escape) {
765
                e.Handled = true;
766
                Close();
767
            }
768
            else if (e.KeyCode == Keys.Delete && e.Modifiers == Keys.Control &&
769
                     !dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].IsInEditMode)
770
                DeleteLineStripButton_Click(sender, e);
771
            else if (e.Control && e.KeyCode == Keys.Subtract) {
772
                if (FontSizeComboBox.SelectedIndex == 0)
773
                    return;
774
                FontSizeComboBox.SelectedIndex--;
775
            }
776
            else if (e.Control && e.KeyCode == Keys.Add) {
777
                if (FontSizeComboBox.SelectedIndex == FontSizeComboBox.Items.Count - 1)
778
                    return;
779
                FontSizeComboBox.SelectedIndex++;
780
            }
781
        }
782

783
        private void MessageEditor_KeyUp(object sender, KeyEventArgs e)
784
        {
785
            if (e.KeyCode == Keys.ShiftKey) shiftKeyDown = false;
786
        }
787

788
        private void MessageEditor_FormClosing(object sender, FormClosingEventArgs e)
789
        {
790
            if (msgSaveButton.Enabled) {
791
                var result = MessageBox.Show("Do you want to save changes to message file?", "Warning", MessageBoxButtons.YesNoCancel);
792
                if (result == DialogResult.Yes) {
793
                    msgSaveButton.PerformClick();
794
                } else if (result == DialogResult.Cancel)
795
                    e.Cancel = true;
796
            }
797
        }
798

799
        string restoreText;
800
        bool textNeedRestore = false;
801

802
        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
803
        {
804
            bool cancelPress = false;
805
            if (textNeedRestore && keyData == Keys.Escape) {
806
                isCancelEdit = true;
807
                dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].Value = restoreText;
808
                isCancelEdit = false;
809
            } else if (isEditMode) {
810
                int keyPress = (int)msg.WParam;
811
                int caretPossiton = ((TextBox)dgvMessage.EditingControl).SelectionStart;
812
                if ((keyPress == 40 || keyPress == 38)) { // Up/Down
813
                    var lines = ((TextBox)dgvMessage.EditingControl).Lines;
814
                    if (lines.Length == 1) {
815
                        if (keyPress == 40) // down
816
                            msg.WParam = (IntPtr)35;
817
                        else
818
                            msg.WParam = (IntPtr)36;
819
                    } else {
820
                        int len = lines[0].Length;
821
                        if (keyPress == 40) { // down
822
                            for (int i = 1; i < lines.Length - 1; i++) len += lines[i].Length + 2;
823
                            if (caretPossiton > len)
824
                                cancelPress = true;
825
                        } else {
826
                            if (caretPossiton <= len)
827
                                cancelPress = true;
828
                        }
829
                    }
830
                } else if (keyPress == 37) { // Left
831
                    if (caretPossiton == 0)
832
                        cancelPress = true;
833
                } else if (keyPress == 39) { // Right
834
                    if (caretPossiton == ((TextBox)dgvMessage.EditingControl).TextLength)
835
                        cancelPress = true;
836
                } else if ((keyPress == 35 || keyPress == 36)) { // Home/End
837
                    if (keyPress == 36)
838
                        ((TextBox)dgvMessage.EditingControl).SelectionStart = 0;
839
                    else
840
                        ((TextBox)dgvMessage.EditingControl).SelectionStart = ((TextBox)dgvMessage.EditingControl).TextLength;
841
                    cancelPress = true;
842
                }
843
            }
844
            if (cancelPress) msg.WParam = (IntPtr)0;
845
            return base.ProcessCmdKey(ref msg, keyData);
846
        }
847

848
        private void dgvMessage_KeyPress(object sender, KeyPressEventArgs e)
849
        {
850
            if (!Char.IsControl(e.KeyChar)) {
851
                if (SelectLine.col == 1)
852
                    dgvMessage.BeginEdit(true);
853
                else {
854
                    textNeedRestore = true;
855
                    restoreText = (string)dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].Value;
856
                    isCancelEdit = true;
857
                    dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].Value = restoreText + e.KeyChar;
858
                    isCancelEdit = false;
859
                    dgvMessage.BeginEdit(false);
860
                }
861
            }
862
        }
863

864
        private void dgvMessage_KeyDown(object sender, KeyEventArgs e)
865
        {
866
            if (e.KeyCode == Keys.Enter && e.Control && !dgvMessage.MultiSelect) {
867
                InsertEmptyStripButton_Click(sender, EventArgs.Empty);
868
                e.SuppressKeyPress = true;
869
            } else if (e.KeyCode == Keys.Enter && e.Shift && !dgvMessage.MultiSelect) {
870
                InsertEmptyStripButton_Click(null, EventArgs.Empty);
871
                e.SuppressKeyPress = true;
872
            } else if (e.KeyCode == Keys.Enter && !dgvMessage.MultiSelect) {
873
                string _cell = (string)dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col].Value;
874
                if (_cell != null && _cell.Length > 0 || !AddNewLine()) {
875
                    dgvMessage.BeginEdit(false);
876
                }
877
                 e.SuppressKeyPress = true;
878
            } else if ((e.KeyCode == Keys.Delete && !e.Control) || e.KeyCode== Keys.Back && !dgvMessage.MultiSelect) {
879
                BackspaceEdit();
880
            }
881
        }
882

883
        private void BackspaceEdit()
884
        {
885
            var _cell = dgvMessage.Rows[SelectLine.row].Cells[SelectLine.col];
886
            var data = _cell.Value;
887
            isCancelEdit = true;
888
            _cell.Value = String.Empty;
889
            dgvMessage.BeginEdit(false);
890
            _cell.Value = data;
891
            isCancelEdit = false;
892
        }
893

894
        private void playerMarkerToolStripMenuItem_Click(object sender, EventArgs e)
895
        {
896
            Entry entry = (Entry)dgvMessage.Rows[SelectLine.row].Cells[0].Tag;
897
            if (entry.msgLine == "-")
898
                return;
899

900
            isCancelEdit = true;
901

902
            bool changed = (dgvMessage.Rows[SelectLine.row].Cells[1].Style.ForeColor == Color.Red);
903

904
            string text;
905
            if (entry.pcMark) {
906
                text = entry.msgText;
907
                entry.pcMark = false;
908
                if (!changed)
909
                    dgvMessage.Rows[SelectLine.row].Cells[1].Style.ForeColor = dgvMessage.RowsDefaultCellStyle.ForeColor;
910
            } else {
911
                text = pcMarker + entry.msgText;
912
                entry.pcMark = true;
913
                if (!changed)
914
                    dgvMessage.Rows[SelectLine.row].Cells[1].Style.ForeColor = pcColor;
915
            }
916

917
            dgvMessage.Rows[SelectLine.row].Cells[1].Value = text;
918
            isCancelEdit = false;
919
            msgSaveButton.Enabled = true;
920
        }
921

922
        private void MoveToolStripButton_Click(object sender, EventArgs e)
923
        {
924
            if (MoveToolStripButton.Checked) {
925
                EnabledControls(false);
926
                dgvMessage.EditMode = DataGridViewEditMode.EditProgrammatically;
927
                dgvMessage.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
928
                dgvMessage.Cursor = Cursors.Hand;
929
            } else {
930
                EnabledControls(true);
931
                dgvMessage.EditMode = DataGridViewEditMode.EditOnKeystrokeOrF2;
932
                dgvMessage.SelectionMode = DataGridViewSelectionMode.CellSelect;
933
                dgvMessage.Cursor = DefaultCursor;
934
            }
935
        }
936

937
        private void EnabledControls(bool status)
938
        {
939
            dgvMessage.MultiSelect = !status;
940
            SendStripButton.Enabled = status;
941
            IncAddStripButton.Enabled = status;
942
            InsertEmptyStripButton.Enabled = status;
943
            InsertCommentStripButton.Enabled = status;
944
            addToolStripMenuItem.Enabled = status;
945
            BackStripButton.Enabled = status;
946
            NextStripButton.Enabled = status;
947
            playerMarkerToolStripMenuItem.Enabled = status;
948
            sendLineToolStripMenuItem.Enabled = status;
949
            addDescriptionToolStripMenuItem.Enabled = status;
950
        }
951

952
        private void moveUpToolStripMenuItem_Click(object sender, EventArgs e)
953
        {
954
            if (dgvMessage.MultiSelect) {
955
                DataGridViewSelectedRowCollection rows = dgvMessage.SelectedRows;
956
                int index_min = Math.Min(rows[0].Index, rows[rows.Count - 1].Index) - 1;
957
                int index_max = Math.Max(rows[0].Index, rows[rows.Count - 1].Index);
958

959
                if (index_min < 0) return;
960

961
                DataGridViewRow row = dgvMessage.Rows[index_min];
962
                dgvMessage.Rows.RemoveAt(index_min);
963
                dgvMessage.Rows.Insert(index_max, row);
964

965
                msgSaveButton.Enabled = true;
966

967
            } else if (SelectLine.row > 0) {
968
                DataGridViewRow row = dgvMessage.Rows[--SelectLine.row];
969
                dgvMessage.Rows.RemoveAt(SelectLine.row);
970
                dgvMessage.Rows.Insert(SelectLine.row + 1, row);
971

972
                msgSaveButton.Enabled = true;
973
            }
974
        }
975

976
        private void moveDownToolStripMenuItem_Click(object sender, EventArgs e)
977
        {
978
            if (dgvMessage.MultiSelect) {
979
                DataGridViewSelectedRowCollection rows = dgvMessage.SelectedRows;
980
                int index_min = Math.Min(rows[0].Index, rows[rows.Count - 1].Index);
981
                int index_max = Math.Max(rows[0].Index, rows[rows.Count - 1].Index) + 1;
982

983
                if (index_max > dgvMessage.Rows.Count - 1) return;
984

985
                DataGridViewRow row = dgvMessage.Rows[index_max];
986
                dgvMessage.Rows.RemoveAt(index_max);
987
                dgvMessage.Rows.Insert(index_min, row);
988

989
                msgSaveButton.Enabled = true;
990

991
            } else if (SelectLine.row < dgvMessage.Rows.Count - 1) {
992
                DataGridViewRow row = dgvMessage.Rows[++SelectLine.row];
993
                dgvMessage.Rows.RemoveAt(SelectLine.row);
994
                dgvMessage.Rows.Insert(SelectLine.row - 1, row);
995

996
                msgSaveButton.Enabled = true;
997
            }
998
        }
999

1000
        private void dgvMessage_CellBeginEdit(object sender, DataGridViewCellCancelEventArgs e)
1001
        {
1002
            var _cell = dgvMessage.Rows[e.RowIndex].Cells[e.ColumnIndex];
1003
            editColor = _cell.Style.BackColor;
1004
            _cell.Style.BackColor = Color.Beige;
1005
            dgvMessage.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
1006
            isEditMode = true;
1007
        }
1008

1009
        private void dgvMessage_CellEndEdit(object sender, DataGridViewCellEventArgs e)
1010
        {
1011
            dgvMessage.Rows[e.RowIndex].Cells[e.ColumnIndex].Style.BackColor = editColor;
1012
            dgvMessage.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders;
1013
            textNeedRestore = false;
1014
            isEditMode = false;
1015
        }
1016

1017
        private void alwaysOnTopToolStripMenuItem_CheckedChanged(object sender, EventArgs e)
1018
        {
1019
            if (alwaysOnTopToolStripMenuItem.Checked)
1020
                this.Owner = scriptForm;
1021
            else
1022
                this.Owner = null;
1023
        }
1024

1025
        private void FontSizeChanged(object sender, EventArgs e)
1026
        {
1027
            int size = int.Parse(FontSizeComboBox.Text);
1028
            dgvMessage.Columns[1].DefaultCellStyle.Font = new Font(dgvMessage.Columns[1].DefaultCellStyle.Font.Name, size, FontStyle.Regular);
1029

1030
            // set for line column
1031
            switch (size) {
1032
                case 24:
1033
                    size -= 10; // 14
1034
                    break;
1035
                case 20:
1036
                    size -= 7; // 13
1037
                    break;
1038
                case 18:
1039
                    size -= 6; // 12
1040
                    break;
1041
                case 16:
1042
                    size -= 5; // 11
1043
                    break;
1044
                case 14:
1045
                    size -= 4; // 10
1046
                    break;
1047
                case 12:
1048
                    size -= 3; // 9
1049
                    break;
1050
                default:
1051
                    size -= 1; // 9/8
1052
                    break;
1053
            }
1054
            dgvMessage.Columns[0].DefaultCellStyle.Font = new Font(dgvMessage.Columns[0].DefaultCellStyle.Font.Name, size, FontStyle.Bold);
1055

1056
            if (size >= 13) {
1057
                dgvMessage.Columns[0].Width = 75;
1058
            } else if (size >= 11) {
1059
                dgvMessage.Columns[0].Width = 65;
1060
            } else {
1061
                dgvMessage.Columns[0].Width = 50;
1062
            }
1063

1064
            if (sender != null) Settings.msgFontSize = (byte)FontSizeComboBox.SelectedIndex;
1065
        }
1066

1067
        private void HighlightingCheck(object sender, EventArgs e)
1068
        {
1069
            Settings.msgHighlightComment = HighlightingCommToolStripMenuItem.Checked;
1070

1071
            if (dgvMessage.RowCount > 0)
1072
                HighlightingCommentUpdate();
1073
        }
1074

1075
        private void ColorComboBox_SelectedIndexChanged(object sender, EventArgs e)
1076
        {
1077
            if (dgvMessage.RowCount > 0)
1078
                Settings.msgHighlightColor = (byte)ColorComboBox.SelectedIndex;
1079

1080
            SetCommentColor();
1081

1082
            if (dgvMessage.RowCount > 0)
1083
                HighlightingCommentUpdate();
1084
        }
1085

1086
        private void dgvMessage_CellMouseClick(object sender, DataGridViewCellMouseEventArgs e)
1087
        {
1088
            if (e.RowIndex > -1 && e.Button == MouseButtons.Middle) {
1089
                dgvMessage.Rows[e.RowIndex].Selected = true;
1090
                SelectLine.row = e.RowIndex;
1091
                sendLineToolStripMenuItem.PerformClick();
1092
            }
1093
        }
1094

1095
        private void dgvMessage_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
1096
        {
1097
            if (e.RowIndex > -1)
1098
                dgvMessage.BeginEdit(true);
1099
        }
1100

1101
        private void dgvMessage_CellClick(object sender, DataGridViewCellEventArgs e)
1102
        {
1103
            if (e.RowIndex == -1)
1104
                return;
1105

1106
            if (editAllowed && dgvMessage.Rows[e.RowIndex].Cells[e.ColumnIndex].Selected)
1107
                dgvMessage.BeginEdit(false);
1108

1109
            editAllowed = true;
1110
        }
1111

1112
        private void addDescriptionToolStripMenuItem_Click(object sender, EventArgs e)
1113
        {
1114
            Entry entry = (Entry)dgvMessage.Rows[SelectLine.row].Cells[0].Tag;
1115
            string desc = entry.description.TrimStart();
1116
            if (InputBox.ShowDialog("Add/Edit Description line", ref desc, 125) == DialogResult.OK) {
1117
                desc = desc.Trim();
1118
                if (desc.Length > 0 && !desc.StartsWith("#")) {
1119
                    desc = desc.Insert(0, " # ");
1120
                }
1121
                entry.description = desc;
1122
                dgvMessage.Rows[SelectLine.row].Cells[1].ToolTipText = entry.description;
1123
                msgSaveButton.Enabled = true;
1124
            }
1125
        }
1126

1127
        private void OpenNotepadtoolStripButton_Click(object sender, EventArgs e)
1128
        {
1129
            if (msgPath != null)
1130
                Settings.OpenInExternalEditor(msgPath);
1131
        }
1132

1133
        private void MessageEditor_Resize(object sender, EventArgs e)
1134
        {
1135
            int width = this.Width - toolStripDropDownButton1.Bounds.Right - 120;
1136
            SearchStripTextBox.Width = (width >= 100) ? width : 100;
1137

1138
            toolStrip.PerformLayout();
1139
            if (SearchStripTextBox.IsOnOverflow) SearchStripTextBox.Width = 240;
1140
        }
1141

1142
        private void openAsTextToolStripMenuItem_Click(object sender, EventArgs e)
1143
        {
1144
            if (msgPath == null) return;
1145

1146
            this.Close();
1147
            if (!this.IsDisposed) return;
1148

1149
            TabInfo ti = ((TextEditor)scriptForm).Open(msgPath, TextEditor.OpenType.File, false);
1150
            if (associateTab != null) associateTab.msgFileTab = ti;
1151
        }
1152

1153
        private void contextMenuStrip1_Opening(object sender, System.ComponentModel.CancelEventArgs e)
1154
        {
1155
            if (isEditMode) e.Cancel = true;
1156
        }
1157

1158
        #region Virtual mode events
1159

1160
        private void dgvMessage_CellValueNeeded(object sender, DataGridViewCellValueEventArgs e)
1161
        {
1162
            //Entry entry = rowsEntry[e.RowIndex];
1163

1164
            //switch (e.ColumnIndex) {
1165
            //case 0:
1166
            //    e.Value = entry.msgLine;
1167
            //    if (entry.commentLine && Settings.msgHighlightComment)
1168
            //        dgvMessage.Rows[e.RowIndex].DefaultCellStyle.BackColor = cmColor;
1169
            //    break;
1170
            //case 1:
1171
            //    e.Value = entry.msgText;
1172
            //    if (entry.pcMark)
1173
            //        dgvMessage.Rows[e.RowIndex].Cells[1].Style.ForeColor = pcColor;
1174
            //    break;
1175
            //case 2:
1176
            //    e.Value = entry.msglip;
1177
            //    break;
1178
            //}
1179
        }
1180

1181
        #endregion
1182
    }
1183
}
1184