Oren's Folder: VBScript Editor [C#]

Hi there. I wrote a simple VBScript Editor in C#, here is a summary of it:

It is a Multiple-Document Interface application, the main menu is merged with a non-visible MenuStrip on the Document form.

Syntax coloring and letter casing is done live, based on the lines affected by the change in the text. The keywords for each color are stored in a regular expression.

Line numbers and column ruler are achieved by RichTextBoxes moved on separate panels. Line and column markers are updated according to the caret's position.

The data for the multiple undo and redo features is stored in Stacks.

Printing is available using the RichTextBoxPrintCtrl from Microsoft.

The tool windows, 'Find\Replace' and 'Jump to line' are always owned by the current active Document.

Here is the code for the Document form:

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Drawing.Printing;

namespace VBScriptEditor
{
    public partial class Document : Form
    {
        public Document()
        {
            // Create the font for all controls, and measure its' character size.
            myFont = new Font("Courier New", 11);
            myFontHeight = TextRenderer.MeasureText("A", myFont).Height;
            myFontWidth = TextRenderer.MeasureText("A", myFont).Width;

InitializeComponent();

// Subscribe to events for printing.
            this.printDocument1.BeginPrint += new System.Drawing.Printing.PrintEventHandler(this.printDocument1_BeginPrint);
            this.printDocument1.PrintPage += new System.Drawing.Printing.PrintPageEventHandler(this.printDocument1_PrintPage);

// Set myFont for all RichTextBox controls on the form.
            // Use its' measurements as a basic unit for the size of all controls.
            columnRulerMarker.Font = columnRulerBox.Font = lineNumbersMarker.Font = lineNumbersBox.Font = richTextBox1.Font = myFont;
            verticalSplitContainer.SplitterDistance = lineNumbersMarker.Width = lineNumbersBox.Width = myFontWidth;
            columnRulerMarker.Width = myFontWidth * 2 / 3;
            horizontalSplitContainer.SplitterDistance = columnRulerMarker.Height = columnRulerBox.Height = lineNumbersMarker.Height = lineNumbersBox.Height = myFontHeight;
            columnRulerMarker.Location = columnRulerBox.Location = new Point((lineNumbersBox.Width + verticalSplitContainer.SplitterWidth), 0);
            columnRulerBox.Width = richTextBox1.Width;
            columnRulerBox.Text = rulerUnit;

// Create the ContextMenuStrip for richTextBox1.
            ToolStripMenuItem[] richTextBox1_MenuGroup1 = new ToolStripMenuItem[2];
            richTextBox1_MenuGroup1[0] = new ToolStripMenuItem("Undo",
                null, new System.EventHandler(undoToolStripMenuItem_Click));
            richTextBox1_MenuGroup1[1] = new ToolStripMenuItem("Redo",
                null, new System.EventHandler(redoToolStripMenuItem_Click));
            ToolStripMenuItem[] richTextBox1_MenuGroup2 = new ToolStripMenuItem[4];
            richTextBox1_MenuGroup2[0] = new ToolStripMenuItem("Cut",
                null, new System.EventHandler(cutToolStripMenuItem_Click));
            richTextBox1_MenuGroup2[1] = new ToolStripMenuItem("Copy",
                null, new System.EventHandler(copyToolStripMenuItem_Click));
            richTextBox1_MenuGroup2[2] = new ToolStripMenuItem("Paste",
                null, new System.EventHandler(pasteToolStripMenuItem_Click));
            richTextBox1_MenuGroup2[3] = new ToolStripMenuItem("Delete",
                null, new System.EventHandler(deleteToolStripMenuItem_Click));
            ToolStripMenuItem[] richTextBox1_MenuGroup3 = new ToolStripMenuItem[1];
            richTextBox1_MenuGroup3[0] = new ToolStripMenuItem("Select All",
                null, new System.EventHandler(selectAllToolStripMenuItem_Click));
            ContextMenuStrip richTextBox1_Menu = new ContextMenuStrip();
            richTextBox1_Menu.Items.AddRange(richTextBox1_MenuGroup1);
            richTextBox1_Menu.Items.Add("-");
            richTextBox1_Menu.Items.AddRange(richTextBox1_MenuGroup2);
            richTextBox1_Menu.Items.Add("-");
            richTextBox1_Menu.Items.AddRange(richTextBox1_MenuGroup3);
            richTextBox1.ContextMenuStrip = richTextBox1_Menu;
            richTextBox1.ContextMenuStrip.Opening += new System.ComponentModel.CancelEventHandler(this.contextMenuStrip_Opening);
            richTextBox1.ContextMenuStrip.Enabled = true;

// Set the tabs for richTextBox1.
            int myTabWidth = myFontWidth * 95 / 100;
            int[] myTabs = new int[32];
            for (int i = 0; i < myTabs.Length; i++)
            {
                myTabs[i] = myTabWidth * (i + 1);
            }
            SendMessage(richTextBox1.Handle, EM_SETTABSTOPS, 1, myTabs);

// Arrange the placement of all controls,
            // and update the edit menu items accordingly.
            FixLineNumbers();
            ScrollColumnRuler();
            MoveMarkers();
            MonitorEditMenu();
            saveToolStripMenuItem.Enabled = false;
        }

// needed for window update locking while making adjustments
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern bool LockWindowUpdate(IntPtr hWndLock);

// needed for setting the tabs on richTextBox1
        private const int EM_SETTABSTOPS = 0x00CB;
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr SendMessage(IntPtr h, int msg, int wParam, int[] lParam);

private int checkPrint;

private Font myFont;
        private int myFontHeight, myFontWidth;
        private string rulerUnit = "----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0";
        private string fileName = "";

private Stack undoStack = new Stack();
        private Stack redoStack = new Stack();

private int lastLinesLength;
        private int lastLineNumbersLength = 1;
        
        private int lastKeyPosition;
        private Keys lastKey = new Keys();

// property for getting the document's 
        // filename by the main application form. 
        public string FileName
        {
            get { return fileName; }
        }

// Process syntax coloring, line numbering 
        // and markers location while text is being typed.
        // Any other method which changes the text on richTextBox1
        // will temporarily unsubscribe this method from the TextChanged event.
        private void richTextBox1_TextChanged(object sender, EventArgs e)
        {
            richTextBox1.SelectionChanged -= new System.EventHandler(richTextBox1_SelectionChanged);
            int originStart = richTextBox1.SelectionStart;
            LockWindowUpdate(this.Handle);

// The text is checked a character before and a character after
            // the change location, so in cases of line-breaks
            // both of the new lines will be processed.
            GetLines(originStart - 1, originStart + 1);
            richTextBox1.SelectionStart = originStart;
            MoveMarkers();
            if (richTextBox1.Lines.Length != lastLinesLength)
            {
                FixLineNumbers();
            }
            lineNumbersBox.Location = new Point(0, richTextBox1.GetPositionFromCharIndex(0).Y);
            LockWindowUpdate(IntPtr.Zero);
            lastLinesLength = richTextBox1.Lines.Length;
            saveToolStripMenuItem.Enabled = true;
            richTextBox1.SelectionChanged += new System.EventHandler(richTextBox1_SelectionChanged);
        }

// Gets all lines in a range of character indexes,
        // and sends each line for syntax coloring.
        private void GetLines(int runStart, int runEnd)
        {
            for (int i = richTextBox1.GetLineFromCharIndex(runStart); i <= richTextBox1.GetLineFromCharIndex(runEnd); i++)
            {
                FixLine(i);
            }
        }

// Colors the syntax of a single line.
        private void FixLine(int myLine)
        {
            if (richTextBox1.TextLength < 1)
            {
                richTextBox1.SelectionStart = 0;
                richTextBox1.SelectionStart = 0;
            }
            else
            {
                richTextBox1.Select((richTextBox1.GetFirstCharIndexFromLine(myLine)), (richTextBox1.Lines[myLine].Length));
            }
            richTextBox1.SelectionColor = Color.Black;
            MatchCollection myQuotes = Keywords.QM.Matches(richTextBox1.SelectedText);
            MatchCollection myComments = Keywords.CO.Matches(richTextBox1.SelectedText);
            MatchCollection myFunctions = Keywords.FC.Matches(richTextBox1.SelectedText);
            MatchCollection myStatements = Keywords.ST.Matches(richTextBox1.SelectedText);
            MatchCollection myLetterCase = Keywords.LC.Matches(richTextBox1.SelectedText);
            for (int i = 0; i < myQuotes.Count; i += 2)
            {
                int j = i + 1;
                richTextBox1.SelectionStart = (myQuotes[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine));
                if (j < myQuotes.Count)
                {    
                    richTextBox1.SelectionLength = (1 - myQuotes[i].Index + myQuotes[j].Index);   
                }
                else
                {
                    richTextBox1.SelectionLength = 1;
                }
                richTextBox1.SelectionColor = Color.DeepPink;
                richTextBox1.DeselectAll();
            }
            for (int i = 0; i < myComments.Count; i++)
            {
                richTextBox1.Select((myComments[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine)), (myComments[i].Length));
                if (richTextBox1.SelectionColor == Color.Black)
                {
                    richTextBox1.SelectionLength = richTextBox1.Lines[myLine].Length - myComments[i].Index;
                    richTextBox1.SelectionColor = Color.Green;
                }
            }
            for (int i = 0; i < myFunctions.Count; i++)
            {
                richTextBox1.Select((myFunctions[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine)), (myFunctions[i].Length));
                if (richTextBox1.SelectionColor == Color.Black)
                {
                    richTextBox1.SelectionColor = Color.Red;
                    richTextBox1.SelectionLength = 1;
                    richTextBox1.SelectedText = richTextBox1.SelectedText.ToUpper();
                    if (myFunctions[i].Length > 1)
                    {
                        richTextBox1.SelectionLength = (myFunctions[i].Length - 1);
                        richTextBox1.SelectedText = richTextBox1.SelectedText.ToLower();
                    }
                }
            }
            for (int i = 0; i < myStatements.Count; i++)
            {
                richTextBox1.Select((myStatements[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine)), (myStatements[i].Length));
                if (richTextBox1.SelectionColor == Color.Black)
                {
                    richTextBox1.SelectionColor = Color.Blue;
                    richTextBox1.SelectionLength = 1;
                    richTextBox1.SelectedText = richTextBox1.SelectedText.ToUpper();
                    if (myStatements[i].Length > 1)
                    {
                        richTextBox1.SelectionLength = (myStatements[i].Length - 1);
                        richTextBox1.SelectedText = richTextBox1.SelectedText.ToLower();
                    }
                }
            }
            for (int i = 0; i < myLetterCase.Count; i++)
            {
                richTextBox1.Select((myLetterCase[i].Index + richTextBox1.GetFirstCharIndexFromLine(myLine)), 1);
                if ((richTextBox1.SelectionColor != Color.Black) && (richTextBox1.SelectionColor != Color.DeepPink) && (richTextBox1.SelectionColor != Color.Green))
                {
                    richTextBox1.SelectedText = richTextBox1.SelectedText.ToUpper();
                }
            }
            richTextBox1.DeselectAll();
        }

/* The four methods below are called accrodingly
           during the various adjustements which occur in the Document. */

// Updates the text and height of the lineNumbersBox.
        private void FixLineNumbers()
        {
            string linesLengthString = (richTextBox1.Lines.Length).ToString();
            if (richTextBox1.Lines.Length > lineNumbersBox.Lines.Length + 1)
            {
                lineNumbersBox.Text = "1";
                for (int i = 2; i <= richTextBox1.Lines.Length; i++)
                {
                    lineNumbersBox.AppendText("\n");
                    lineNumbersBox.AppendText(i.ToString());
                }
            }
            else if (richTextBox1.Lines.Length == lineNumbersBox.Lines.Length + 1)
            {
                lineNumbersBox.AppendText("\n");
                lineNumbersBox.AppendText(richTextBox1.Lines.Length.ToString());
            }
            else if (richTextBox1.Lines.Length < 1)
            {
                lineNumbersBox.Text = "1";
            }
            lineNumbersBox.Height = (richTextBox1.Lines.Length * myFontHeight);
            if (linesLengthString.Length != lastLineNumbersLength)
            {
                lineNumbersBox.Width = linesLengthString.Length * myFontWidth;
                lineNumbersMarker.Width = lineNumbersBox.Width;
                verticalSplitContainer.SplitterDistance = lineNumbersBox.Width;
                ScrollColumnRuler();
                MoveMarkers();
            }
            lastLineNumbersLength = linesLengthString.Length;
        }

// Updates the location of the lineNumbersBox 
        // and lineNumbersMarker for scrolling.
        private void ScrollLineNumbers()
        {
            lineNumbersBox.Location = new Point(0, richTextBox1.GetPositionFromCharIndex(0).Y);
            lineNumbersMarker.Location = new Point(0, richTextBox1.GetPositionFromCharIndex(richTextBox1.SelectionStart).Y);
        }

// Updates the location and of the columnRulerBox 
        // and columnRulerMarker for scrolling.
        // Appends the columnRulerBox with more units if needed.
        private void ScrollColumnRuler()
        {
            columnRulerBox.Location = new Point((richTextBox1.GetPositionFromCharIndex(0).X + lineNumbersBox.Width + verticalSplitContainer.SplitterWidth), 0);
            columnRulerBox.Width = columnRulerBox.Location.X * -1 + this.Width;
            if ((columnRulerBox.Width * 2) > (columnRulerBox.TextLength * myFontWidth))
            {
                columnRulerBox.AppendText(rulerUnit);
            }
        }

// Updates both markers location for non-scrolling actions
        // and sets them with the appropriate text.
        private void MoveMarkers()
        {
            lineNumbersMarker.Location = new Point(0, richTextBox1.GetPositionFromCharIndex(richTextBox1.SelectionStart).Y);
            lineNumbersMarker.Text = ((lineNumbersMarker.Location.Y + lineNumbersBox.Location.Y * -1) / myFontHeight + 1).ToString();
            columnRulerMarker.Location = new Point((richTextBox1.GetPositionFromCharIndex(richTextBox1.SelectionStart).X + lineNumbersBox.Width + verticalSplitContainer.SplitterWidth), 0);
            columnRulerMarker.Text = (columnRulerBox.GetCharFromPosition(new Point(columnRulerBox.Width - this.Width + columnRulerMarker.Location.X, 0)).ToString());
        }

// Uses to block focus from any control other than richTextBox1.
        private void richTextBox2_Enter(object sender, EventArgs e)
        {
            richTextBox1.Focus();
        }

/* The four methods below call the appropriate methods
           when resizing the form, scrolling richTextBox1 
           and moving the caret in richTextBox1. */

private void richTextBox1_VScroll(object sender, EventArgs e)
        {
            ScrollLineNumbers();
        }

private void Form1_SizeChanged(object sender, EventArgs e)
        {
            if (this.WindowState != FormWindowState.Maximized)
            {
                ScrollLineNumbers();
            }
            ScrollColumnRuler();
            MoveMarkers();
        }

private void richTextBox1_SelectionChanged(object sender, EventArgs e)
        {
            MoveMarkers();

// Call the method to update edit menu items,
            // since the cut, copy and delete items are enabled 
            // and disabled according to the selection start and length.
            MonitorEditMenu();
        }

private void richTextBox1_HScroll(object sender, EventArgs e)
        {
            ScrollColumnRuler();
            MoveMarkers();
        }

// Processes keys pressed on richTextBox1,
        // and determines wheter to push the state before into the Undo stack.
        private void richTextBox1_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
        {
            if (!e.Control && !e.Alt && !e.Shift && (e.KeyData < Keys.Prior || e.KeyData > Keys.Insert) &&
                ((lastKey < Keys.A || lastKey > Keys.Z) || (richTextBox1.SelectionStart != lastKeyPosition + 1)))
            {
                PushEdit();
            }

// The data and caret location for the last key pressed
            // are used for comparison with the current key pressed.
            lastKey = e.KeyData;
            lastKeyPosition = richTextBox1.SelectionStart;
        }

// Enables and disables the edit menu items appropriatly.
        private void MonitorEditMenu()
        {
            if (undoStack.Count < 1)
            {
                undoToolStripMenuItem.Enabled = false;
            }
            else
            {
                undoToolStripMenuItem.Enabled = true;
            }
            if (redoStack.Count < 1)
            {
                redoToolStripMenuItem.Enabled = false;
            }
            else
            {
                redoToolStripMenuItem.Enabled = true;
            }
            if (richTextBox1.SelectionLength < 1)
            {
                cutToolStripMenuItem.Enabled = false;
                copyToolStripMenuItem.Enabled = false;
            }
            else
            {
                cutToolStripMenuItem.Enabled = true;
                copyToolStripMenuItem.Enabled = true;
            }
            if (richTextBox1.SelectionStart == richTextBox1.TextLength)
            {
                deleteToolStripMenuItem.Enabled = false;
            }
            else
            {
                deleteToolStripMenuItem.Enabled = true;
            }
            if (richTextBox1.TextLength < 1)
            {
                selectAllToolStripMenuItem.Enabled = false;
            }
            else
            {
                selectAllToolStripMenuItem.Enabled = true;
            }
            if (!Clipboard.ContainsText())
            {
                pasteToolStripMenuItem.Enabled = false;
            }
            else
            {
                pasteToolStripMenuItem.Enabled = true;
            }
        }

/* The methods below process the tasks of each menu strip item,
           in the order of their appearance. */

public void FileOpen(string myFileName)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            LockWindowUpdate(this.Handle);
            fileName = myFileName;
            richTextBox1.LoadFile(fileName, RichTextBoxStreamType.PlainText);
            GetLines(0, richTextBox1.TextLength);
            FixLineNumbers();
            richTextBox1.SelectionStart = 0;
            saveToolStripMenuItem.Enabled = false;
            LockWindowUpdate(IntPtr.Zero);
            MonitorEditMenu();
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);
        }

private void closeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
        }

private void Document_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (saveToolStripMenuItem.Enabled == true)
            {
                DialogResult result;
                result = MessageBox.Show("Save changes to '" + this.Text + "'?", "VBScript Editor",
                    MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button3);
                if (result == DialogResult.Yes)
                {
                    saveAsToolStripMenuItem_Click(sender, e);
                }
                else if (result == DialogResult.Cancel)
                {
                    e.Cancel = true;
                }
            }
        }

private void saveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (fileName != "")
            {
                richTextBox1.SaveFile(fileName, RichTextBoxStreamType.PlainText);
                saveToolStripMenuItem.Enabled = false;
            }
            else
            {
                saveAsToolStripMenuItem_Click(sender, e);
            }
        }

private void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveFileDialog saveFile1 = new SaveFileDialog();
            saveFile1.OverwritePrompt = true;
            saveFile1.DefaultExt = ("*.vbs");
            saveFile1.Filter = "All Files (*.vbs;*.txt)|*.vbs;*.txt|VBScript (*.vbs)|*.vbs|Text Files (*.txt)|*.txt";
            if (fileName != "")
            {
                saveFile1.FileName = fileName.Substring(fileName.LastIndexOf("\\") + 1);
                saveFile1.InitialDirectory = (fileName.Remove(fileName.LastIndexOf("\\") + 1));
            }
            else
            {
                saveFile1.FileName = this.Text;
            }
            if (saveFile1.ShowDialog() == System.Windows.Forms.DialogResult.OK &&
               saveFile1.FileName.Length > 0)
            {
                fileName = saveFile1.FileName;
                this.Text = saveFile1.FileName.Substring(fileName.LastIndexOf("\\") + 1);
                richTextBox1.SaveFile(saveFile1.FileName, RichTextBoxStreamType.PlainText);
                saveToolStripMenuItem.Enabled = false;
            }
        }

/* The five methods below are copied from Microsoft's RichTextBoxPrintCtrl
           tutorial for printing RichTextBox contents. */

private void pageSetupToolStripMenuItem_Click(object sender, EventArgs e)
        {
            pageSetupDialog1.ShowDialog();
        }

private void printPreviewToolStripMenuItem_Click(object sender, EventArgs e)
        {
            printPreviewDialog1.ShowDialog();
        }

private void printToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (printDialog1.ShowDialog() == DialogResult.OK)
                printDocument1.Print();
        }

private void printDocument1_BeginPrint(object sender, System.Drawing.Printing.PrintEventArgs e)
        {
            checkPrint = 0;
        }

private void printDocument1_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e)
        {
            // Print the content of RichTextBox. Store the last character printed.
            checkPrint = richTextBox1.Print(checkPrint, richTextBox1.TextLength, e);

// Check for more pages
            if (checkPrint < richTextBox1.TextLength)
                e.HasMorePages = true;
            else
                e.HasMorePages = false;
        }

private void undoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            if (undoStack.Count > 0)
            {
                LockWindowUpdate(this.Handle);

// The Undo first pushes the current state
                // into the Redo stack.
                Hashtable myState = new Hashtable();
                myState["text"] = richTextBox1.Rtf;
                myState["position"] = richTextBox1.SelectionStart;
                redoStack.Push(myState);

// Then, the last state is popped from the Undo stack.
                Hashtable undoState = (Hashtable)undoStack.Pop();
                richTextBox1.Rtf = (string)undoState["text"];
                richTextBox1.SelectionStart = (int)undoState["position"];

FixLineNumbers();
                LockWindowUpdate(IntPtr.Zero);
                saveToolStripMenuItem.Enabled = true;
            }
            MonitorEditMenu();
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);
        }

private void redoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            if (redoStack.Count > 0)
            {
                LockWindowUpdate(this.Handle);

// The Redo first pushes the current state
                // into the Undo stack.
                Hashtable myState = new Hashtable();
                myState["text"] = richTextBox1.Rtf;
                myState["position"] = richTextBox1.SelectionStart;
                undoStack.Push(myState);

// Then, the last state is popped from the Redo stack.
                Hashtable redoState = (Hashtable)redoStack.Pop();
                richTextBox1.Rtf = (string)redoState["text"];
                richTextBox1.SelectionStart = (int)redoState["position"];
                FixLineNumbers();
                LockWindowUpdate(IntPtr.Zero);
                saveToolStripMenuItem.Enabled = true;
            }
            MonitorEditMenu();
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);
        }

// Pushes a state into the Undo stack.
        // This method is always called before the change 
        // in the text is applied (e.g. the PreviewKeyDown event).
        public void PushEdit()
        {
            redoStack.Clear();
            Hashtable myState = new Hashtable();
            myState["text"] = richTextBox1.Rtf;
            myState["position"] = richTextBox1.SelectionStart;
            undoStack.Push(myState);
        }

private void cutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clipboard.SetDataObject(richTextBox1.SelectedText);
            richTextBox1.SelectedText = "";
        }

private void copyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clipboard.SetDataObject(richTextBox1.SelectedText);
            MonitorEditMenu();
        }

private void pasteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            if (Clipboard.ContainsText())
            {
                PushEdit();
                LockWindowUpdate(this.Handle);
                int originStart = richTextBox1.SelectionStart;
                richTextBox1.Paste(DataFormats.GetFormat("Text"));
                int newLocation = richTextBox1.SelectionStart;

// The recoloring range after pasting text
                // starts on the line where the caret was pre-paste,
                // and ends with the line of its' post-paste location.
                GetLines(originStart, newLocation);

FixLineNumbers();
                richTextBox1.SelectionStart = newLocation;
                LockWindowUpdate(IntPtr.Zero);
                saveToolStripMenuItem.Enabled = true;
            }
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);
        }

private void deleteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (richTextBox1.SelectionLength < 1)
            {
                richTextBox1.SelectionLength = 1;
            }
            richTextBox1.SelectedText = "";
        }

/* The eight methods below are for the Find\Replace 
           and Jump to line tools. */

private void findReplaceToolStripMenuItem_Click(object sender, EventArgs e)
        {
            RenewToolWindows();
            ((Main)(this.MdiParent)).FindReplaceWindow.Visible = true;
            ((Main)(this.MdiParent)).FindReplaceWindow.Focus();
        }

public int FindTextDown(string myFind)
        {
            int findResult = -1;
            richTextBox1.Select(richTextBox1.SelectionStart + richTextBox1.SelectionLength, 0);
            findResult = richTextBox1.Find(myFind, richTextBox1.SelectionStart, richTextBox1.TextLength, RichTextBoxFinds.None);
            if (findResult == -1)
            {
                findResult = richTextBox1.Find(myFind, 0, richTextBox1.TextLength , RichTextBoxFinds.None);
            }

if (findResult != -1)
            {
                return richTextBox1.SelectionStart;
            }
            else
            {
                return findResult;
            }
        }

public int FindTextUp(string myFind)
        {
            int findResult = -1;
            richTextBox1.Select(richTextBox1.SelectionStart, 0);
            findResult = richTextBox1.Find(myFind, 0, richTextBox1.SelectionStart, RichTextBoxFinds.Reverse);
            if (findResult == -1)
            {
                findResult = richTextBox1.Find(myFind, 0, richTextBox1.TextLength, RichTextBoxFinds.Reverse);
            }
            return findResult;
        }

public void ReplaceText(string myFind, string myReplace)
        {
            richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            if (richTextBox1.SelectedText.ToLower() == myFind.ToLower())
            {
                PushEdit();
                LockWindowUpdate(this.Handle);
                int originStart = richTextBox1.SelectionStart;
                richTextBox1.SelectedText = myReplace;
                int newLocation = richTextBox1.SelectionStart;
                GetLines(originStart, newLocation);
                FixLineNumbers();
                richTextBox1.SelectionStart = newLocation;
                LockWindowUpdate(IntPtr.Zero);
                saveToolStripMenuItem.Enabled = true;
            }
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);          
        }

public int ReplaceAllText(string myFind, string myReplace)
        {
            int replaceCount = 0;

richTextBox1.TextChanged -= new System.EventHandler(richTextBox1_TextChanged);
            PushEdit();
            LockWindowUpdate(this.Handle);
            richTextBox1.Select(0, 0);
            while (richTextBox1.Find(myFind, richTextBox1.SelectionStart, richTextBox1.TextLength, RichTextBoxFinds.None) != -1)
            {
                richTextBox1.SelectedText = myReplace;
                richTextBox1.SelectionStart += myReplace.Length;
                replaceCount++;
            }
            GetLines(0, richTextBox1.TextLength);
            FixLineNumbers();
            richTextBox1.SelectionStart = 0;
            LockWindowUpdate(IntPtr.Zero);
            saveToolStripMenuItem.Enabled = true;
            richTextBox1.TextChanged += new System.EventHandler(richTextBox1_TextChanged);

return replaceCount;
        }

private void jumpToLineToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ((Main)(this.MdiParent)).JumpToLineWindow.Visible = true;
            ((Main)(this.MdiParent)).JumpToLineWindow.Focus();
        }

public int JumpToLine(int myLine)
        {
            try
            {
                richTextBox1.Select((richTextBox1.GetFirstCharIndexFromLine(myLine - 1)), 0);
            }
            catch
            {
                if ((myLine < 1) || (richTextBox1.TextLength < 1))
                {
                    myLine = 1;
                }
                else if (myLine > richTextBox1.Lines.Length)
                {
                    myLine = richTextBox1.Lines.Length;
                }
            }
            finally
            {
                richTextBox1.Select((richTextBox1.GetFirstCharIndexFromLine(myLine - 1)), 0);
            }
            richTextBox1.Focus();
            return myLine;
        }

// Checks if each of the tool windows are disposed, 
        // and calls a Main application method to re-initialize them.
        private void RenewToolWindows()
        {
            if (((Main)(this.MdiParent)).FindReplaceWindow.IsDisposed)
            {
                ((Main)(this.MdiParent)).RenewFindReplaceWindow();
            }

if (((Main)(this.MdiParent)).JumpToLineWindow.IsDisposed)
            {
                ((Main)(this.MdiParent)).RenewJumpToLineWindow();
            }
        }

private void selectAllToolStripMenuItem_Click(object sender, EventArgs e)
        {
            richTextBox1.SelectAll();
        }

/* Here end the methods for the menu strip items. */

// Enables and disables the ContextMenuStrip items on opening,
        // accroding the items' state in the edit menu.
        private void contextMenuStrip_Opening(object sender, CancelEventArgs e)
        {
            if (undoToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[0].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[0].Enabled = false;
            }
            if (redoToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[1].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[1].Enabled = false;
            }
            if (cutToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[3].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[3].Enabled = false;
            }
            if (copyToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[4].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[4].Enabled = false;
            }
            if (pasteToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[5].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[5].Enabled = false;
            }
            if (deleteToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[6].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[6].Enabled = false;
            }
            if (selectAllToolStripMenuItem.Enabled == true)
            {
                richTextBox1.ContextMenuStrip.Items[8].Enabled = true;
            }
            else
            {
                richTextBox1.ContextMenuStrip.Items[8].Enabled = false;
            }
        }

// When a Document is activated, the edit menu is updated
        // according the active Document state,
        // and the Document takes ownership of the tool windows.
        private void Document_Activated(object sender, EventArgs e)
        {
            MonitorEditMenu();
            FixLineNumbers();
            RenewToolWindows();
            ((Main)(this.MdiParent)).FindReplaceWindow.Owner = this;
            ((Main)(this.MdiParent)).JumpToLineWindow.Owner = this;
        }
    }
}

Oren's Folder

Monday, October 5, 2009

VBScript Editor [C#]

No comments:

Post a Comment

Blog Archive

Labels

Contact Me:

Disclaimer