//EdSharp 1.2
//August 22, 2007
//Copyright 2006 - 2007 by Jamal Mazrui
//Modified GPL License

using Microsoft.VisualBasic;
using Microsoft.VisualBasic.ApplicationServices;
using Microsoft.VisualBasic.Compatibility.VB6;
using MyIO = Microsoft.VisualBasic.FileIO;
using Microsoft.VisualBasic.MyServices;
using Microsoft.Win32;
using System;
//using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Windows.Forms;

namespace EdSharp{
public class App : WindowsFormsApplicationBase {
public static App Shell;
public static MdiFrame Frame;
public static string ProgramName;
public static string ProgramDir;
public static string DataDir;
public static string DefaultIniFile;
public static string IniFile;
public static string TempFile;
public static List<string> TempFiles = new List<string>();
//public static object Word = null;
public static object Wineyes = null;
public static bool WordCreated = false;

[STAThread]
public static void Main(string[] cmdLineArgs) {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(true);
Application.OleRequired();

//Dialog.Show(Util.ProperCase("this dog"));
Shell = new App();
Frame = new MdiFrame();
Shell.MainForm = Frame;
MdiChild child = new MdiChild(Frame);
if (cmdLineArgs.Length > 0) {
string sFile = cmdLineArgs[0];
Frame.OpenOrActivateWindow(sFile, 1);
/*
child.RTB.LoadFile(sFile, RichTextBoxStreamType.PlainText);
child.File = sFile;
child.Text = Path.GetFileName(sFile);
child.RTB.Modified = false;
Frame.ApplyFileOptions(sFile);
Frame.SetRecent(sFile);
*/
}
Shell.Run(cmdLineArgs);
} // Main method

public App() {
this.IsSingleInstance = true;
App.ProgramName = GetAppName();
App.ProgramDir = GetProgramDir();
App.DataDir = GetDataDir();
App.TempFile = GetTempFile();
App.DefaultIniFile = GetDefaultIniFile();
App.IniFile = GetIniFile();
SetConfigurationValues();

InitJFW();

this.Shutdown += delegate(object o, EventArgs e) {
if (App.WordCreated) {
Util.Say("Exiting Microsoft Word");
COM.WordExit();
}
if (App.Wineyes != null) COM.Release(ref App.Wineyes);

foreach (string sFile in App.TempFiles) if (File.Exists(sFile)) File.Delete(sFile);
};

this.UnhandledException += delegate(object sender, Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventArgs e) {
Exception ex = (Exception) e.Exception;
string sMessage = ex.Message;
sMessage += "\nExit EdSharp?\n\nStack trace:\n" + ex.StackTrace;
e.ExitApplication = Dialog.Confirm("Confirm", "Unusual event!\n" + sMessage + ".\nExit EdSharp?", "N") == "Y";
};

} // App constructor

protected override void OnStartupNextInstance(StartupNextInstanceEventArgs e) {
App.Frame.Activate();
Win32.SetForegroundWindow(App.Frame.Handle);
if (e.CommandLine.Count == 0) return;
string sFile = Util.Unquote(e.CommandLine[0]);
if (sFile != null && File.Exists(sFile)) App.Frame.OpenOrActivateWindow(sFile, 1);
} // OnStartUpNextInstance handler

public static bool InitJFW() {
string sDir = Win32.GetJFWDir();
if (sDir.Length == 0) return false;

string sPath = Environment.GetEnvironmentVariable("PATH");
sDir += ";";
if (!sPath.ToLower().Contains(sDir.ToLower())) {
sPath = sDir + sPath;
Environment.SetEnvironmentVariable("PATH", sPath);
}
return true;
} // InitJFW method

public static string GetAppName() {
string sExe = Environment.GetCommandLineArgs()[0];
string sReturn = Path.GetFileNameWithoutExtension(sExe);
return sReturn;
} // GetAppName method

public static string GetProgramDir() {
//string sApp = System.Reflection.Assembly.GetExecutingAssembly().Location;
//string sApp = Application.ExecutablePath;
//string sReturn = Path.GetDirectoryName(sApp);
string sReturn = Application.StartupPath;
return sReturn;
} // GetProgramDir method

public static string GetDataDir() {
string sName = GetAppName();
//string sDir = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
//string sDir = Application.UserAppDataPath;
//string sDir = Application.LocalUserAppDataPath
string sDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
string sReturn = Path.Combine(sDir, sName);
return sReturn;
} // GetDataDir method

public static string GetTempFile() {
string sName = GetAppName() + ".tmp";
string sDir = GetDataDir();
string sReturn = Path.Combine(sDir, sName);
App.TempFiles.Add(sReturn);
return sReturn;
} // GetTempFile method

public static string GetIniFile() {
string sName = GetAppName() + ".ini";
string sDir = GetDataDir();
string sReturn = Path.Combine(sDir, sName);
return sReturn;
} // GetIniFile method

public static string GetDefaultIniFile() {
string sName = GetAppName() + ".ini";
string sDir = GetProgramDir();
string sReturn = Path.Combine(sDir, sName);
return sReturn;
} // GetDefaultIniFile method

public static string ReadData(string sKey, string sDefault) {
string sSection = "Data";
return ReadValue(sSection, sKey, sDefault);
} // ReadData method

public static bool WriteData(string sKey, string sValue) {
string sSection = "Data";
//return WriteValue(sSection, sKey, sValue);
return Ini.WriteQuote(App.IniFile, sSection, sKey, sValue);
} // WriteData method

public static string ReadDefaultOption(string sKey, string sDefault) {
string sSection = "Options";
return Ini.ReadValue(App.DefaultIniFile, sSection, sKey, sDefault);
} // ReadDefaultOption method

public static string ReadOption(string sKey, string sDefault) {
string sSection = "Options";
return ReadValue(sSection, sKey, sDefault);
} // ReadOption method

public static string ReadValue(string sSection, string sKey, string sDefault) {
return Ini.ReadValue(App.IniFile, sSection, sKey, sDefault);
} // ReadValue method

public static bool WriteOption(string sKey, string sValue) {
string sSection = "Options";
return WriteValue(sSection, sKey, sValue);
} // WriteOption method

public static bool WriteValue(string sSection, string sKey, string sValue) {
return Ini.WriteValue(App.IniFile, sSection, sKey, sValue);
} // WriteValue method

public static bool DeleteKey(string sSection, string sKey) {
return Ini.DeleteKey(App.IniFile, sSection, sKey);
} // DeleteKey method

public static bool DeleteSection(string sSection) {
return Ini.DeleteSection(App.IniFile, sSection);
} // DeleteSection method

public static string[] ReadDefaultOptions() {
string sSection = "Options";
return ReadDefaultSectionKeys(sSection);
} // ReadOptions method

public static string[] ReadDefaultSectionKeys(string sSection) {
return Ini.ReadSectionKeys(App.DefaultIniFile, sSection);
} // ReadDefaultSectionKeys method

public static string[] ReadSectionKeys(string sSection) {
return Ini.ReadSectionKeys(App.IniFile, sSection);
} // ReadSectionKeys method

public static string[] ReadSections() {
return Ini.ReadSections(App.IniFile);
} // ReadSections method

public static void SetConfigurationValues() {
string[] aSections = Ini.ReadSections(App.DefaultIniFile);
foreach (string sSection in aSections) {
string[] aCommands = Ini.ReadSectionKeys(App.DefaultIniFile, sSection);
string[] aKeys = new string[aCommands.Length];
for (int i = 0; i < aCommands.Length; i++) {
string sCommand = aCommands[i];
string sKey = Ini.ReadValue(App.DefaultIniFile, sSection, sCommand, "");
sKey = Ini.ReadValue(App.IniFile, sSection, sCommand, sKey);
aKeys[i] = sKey;
}

//Ini.DeleteSection(App.IniFile, sSection);
for (int i = 0; i < aCommands.Length; i++) {
string sCommand = aCommands[i];
string sKey = aKeys[i];
//if (sSection == "Import" || sSection == "Export") Ini.WriteValue(App.IniFile, sSection, sCommand, sKey);
//else Ini.WriteQuote(App.IniFile, sSection, sCommand, sKey);
Ini.WriteQuote(App.IniFile, sSection, sCommand, sKey);
}
}
} // SetConfigurationValues method

} // App class

public class MdiChild : Form {
public HomerRichTextBox RTB;
private string sFile = "";
public string File {
get {
return sFile;
}
set {
sFile = value;
}
} // File property

public MdiChild(MdiFrame frame) {
string sTitle = frame.GetNoNameTitle();
new MdiChild(frame, sTitle);
} // MdiChild constructor

public MdiChild(MdiFrame frame, string sTitle) {
this.SuspendLayout();
this.MdiParent = frame;
HomerRichTextBox rtb = new HomerRichTextBox();
rtb.AccessibleRole = AccessibleRole.Text;
rtb.AutoWordSelection = false;
rtb.Dock = DockStyle.Fill;
rtb.Multiline = true;

string sFont = App.ReadOption("Font", "");
if (sFont.Length > 0) {
string[] a = sFont.Split(',');
List<string> list = new List<string>(a);
int iCount = list.Count;
string sColor = list[iCount - 1];
try {
sColor = sColor.Split('=')[1];
rtb.ForeColor = Util.String2Color(sColor);
}
catch {}

list.RemoveAt(iCount - 1);
a = list.ToArray();
sFont = String.Join(",", a);
try {
rtb.Font = Util.String2Font(sFont);
}
catch {}
}

string s = App.ReadOption("WordWrap", "Y").Trim().ToUpper();
if (s == "N" || s == "NO") rtb.SetWrap(false);
else rtb.SetWrap(true);
//rtb.ScrollBars = RichTextBoxScrollBars.Vertical;
rtb.ScrollBars = RichTextBoxScrollBars.Vertical | RichTextBoxScrollBars.Horizontal;
rtb.AcceptsTab = true;
rtb.FindText = "";
rtb.JumpLine = "";
rtb.GoPercent = "";
rtb.SearchTopic = "";
rtb.SelectionChanged += App.Frame.SetStatusAddress;
this.Controls.Add(rtb);
this.RTB = rtb;
//this.File = frame.GetNoNameTitle();
this.File = sTitle;
this.Text = this.File;
this.StartPosition = FormStartPosition.CenterParent;
this.AutoSize = true;
this.ResumeLayout();
this.KeyPreview = true;
this.Activated += delegate(object o, EventArgs e) {
frame.SetStatusAddress(this, null);
this.WindowState = FormWindowState.Maximized;
};

//this.Shown += delegate(object o, EventArgs e) {this.RTB.Modified = false;};
this.Show();
} // child constructor

public void LoadTextFile(string sFile) {
this.RTB.LoadFile(sFile, RichTextBoxStreamType.PlainText);
this.RTB.Modified = false;
this.Text = Path.GetFileName(sFile);
this.File = sFile;
} // LoadTextFile method

public void SaveTextFile(string sFile) {
this.RTB.SaveFile(sFile, RichTextBoxStreamType.PlainText);
//this.RTB.Modified = false;
this.Text = Path.GetFileName(sFile);
this.File = sFile;
} // SaveTextFile method

protected override bool ProcessCmdKey(ref Message msg, Keys keyData) {
return App.Frame.ProcessCmdKey_Helper(ref msg, keyData);
} // ProcessCmdKey handler

} // MdiChild class

public class MdiFrame : Form {
public MdiChild Child {
get {
MdiChild child = this.ActiveMdiChild as MdiChild;
if (child == null) {
Form[] children = this.MdiChildren;
if (children.Length == 1) child = (MdiChild) children[0];
}
return child;
}
set {
value.Activate();
}
} // Child property

public bool bCommandComplete = true;
public static string CR = "\r";
public static string LF = "\n";
public static string LB = LF;
public static string LineBreak = Environment.NewLine;
public static string FF = "\f";
public static string SB = FF + LB;
public static string DD = "----------";
public static string SectionBreak = LB + DD + LB + SB;
public static string EOD = LB + DD + LB + "End of Document" + LB;

public static Dictionary<Keys, ToolStripMenuItem> hashKey = new Dictionary<Keys, ToolStripMenuItem>();
public MenuStrip menuMain;
public ToolStripMenuItem menuFile, menuFileNew, menuFileNewFromClipboard, menuFileOpen, menuFileOpenOtherFormat, menuFileOpenAgain, menuFileRecent, menuFileSetFavorite, menuFileClearFavorite, menuFileListFavorites, menuFileFind, menuFileSave, menuFileSaveAs, menuFileSaveCopy, menuFileExport, menuFileRename, menuFileProperties, menuFileMailBody, menuFileMailAttach, menuFilePrint, menuFileRun, menuFileCurrentWindows, menuFileClose, menuFileCloseAllButCurrentWindow, menuFileExit;
public ToolStripMenuItem menuEdit, menuEditSelectAll, menuEditUnselectAll, menuEditCopy, menuEditCopyAppend, menuEditCut, menuEditCutAppend, menuEditPaste, menuEditPasteFile, menuEditUndo, menuEditRedo, menuEditStartSelection, menuEditCompleteSelection, menuEditReselect, menuEditCopyAll, menuEditSelectChunk, menuEditQuote, menuEditUnquote, menuEditUpperCase, menuEditLowerCase, menuEditProperCase, menuEditSwapCase, menuEditJoinLines, menuEditHardLineBreak, menuEditEnterNewLine, menuEditIndentNewLine, menuEditIndent, menuEditOutdent, menuEditIndentMode;
public ToolStripMenuItem menuDelete, menuDeleteReplaceRegular, menuDeleteReplaceWithRegExp, menuDeleteLine, menuDeleteRight, menuDeleteLeft, menuDeleteDown, menuDeleteUp, menuDeleteFile, menuDeleteTrimBlanks;
public ToolStripMenuItem menuNavigate, menuNavigateForwardFind, menuNavigateReverseFind, menuNavigateForwardFindAgain, menuNavigateReverseFindAgain, menuNavigateJumpToLine, menuNavigateJumpToLineAgain, menuNavigateGoToPercent, menuNavigateGoToPercentAgain, menuNavigateSetBookmark, menuNavigateClearBookmark, menuNavigateGoToBookmark, menuNavigateHomeCharacter, menuNavigateEndCharacter, menuNavigateRightBrace, menuNavigateLeftBrace, menuNavigateNextBlock, menuNavigatePriorBlock, menuNavigateNextChunk,  menuNavigatePriorChunk, menuNavigateNextSentence, menuNavigatePriorSentence, menuNavigateNextParagraph, menuNavigatePriorParagraph, menuNavigatePriorSection, menuNavigateNextPart, menuNavigatePriorPart, menuNavigateNextSection, menuNavigateGoToSection, menuNavigateGoToContents, menuNavigateSearchForTopic, menuNavigateSearchForTopicAgain, menuNavigateGoToStartOfSelection;
public ToolStripMenuItem menuQuery, menuQueryAddress, menuQueryBraces, menuQueryIndent, menuQueryPath, menuQueryTopic, menuQueryYield, menuQueryStatus, menuQuerySelected, menuQueryChunk, menuQueryReadAll, menuQueryWindowsOpen, menuQueryClipboard, menuQueryTime;
public ToolStripMenuItem menuMisc, menuMiscSetFontAndColor, menuMiscConfigurationOptions, menuMiscManualOptions, menuMiscWordWrap, menuMiscUnwrap, menuMiscSpellCheck, menuMiscThesaurus, menuMiscDictionary, menuMiscGuardDocument, menuMiscNoGuard, menuMiscRepeatLine, menuMiscSectionBreak, menuMiscPathToClipboard, menuMiscPathList, menuMiscInsertTime, menuMiscCalculateDate, menuMiscHTMLFormat, menuMiscTextConvert, menuMiscTextCombine, menuMiscTextContents, menuMiscYieldWithRegExp, menuMiscExtractWithRegExp, menuMiscRunAtCursor, menuMiscEvaluateExpression, menuMiscCompile, menuMiscPickCompiler, menuMiscKeepUniqueLines, menuMiscNumberLines, menuMiscOrderLines, menuMiscReverseLines, menuMiscListDifferentLines, menuMiscQueryCommonLines, menuMiscExplorerFolder, menuMiscCommandPrompt;
public ToolStripMenuItem menuWindow, menuWindowNext, menuWindowPrior;
public ToolStripMenuItem menuHelp, menuHelpAbout, menuHelpDocumentation, menuHelpHistoryOfChanges, menuHelpHotKeySummary, menuHelpAlternateMenu, menuHelpContextMenu, menuHelpSendToMenu, menuHelpElevateVersion;
public StatusStrip statusBar;
public ToolStripStatusLabel lblStatus;

public MdiFrame() {
this.SuspendLayout();
this.IsMdiContainer = true;
menuMain = CreateMainMenu();
menuMain.AccessibleRole = AccessibleRole.MenuBar;
menuFile = CreateMenu("&File");
menuFileNew = CreateMenuItem("&New", "Control+N", menuItem_Click, "frame speak");
menuFileNewFromClipboard = CreateMenuItem("New from Clipboard", "Control+Shift+N", menuItem_Click, "frame speak");
menuFileOpen = CreateMenuItem("&Open ...", "Control+O", menuItem_Click, "frame speak");
menuFileOpenOtherFormat = CreateMenuItem("OpenOtherFormat ...", "Control+Shift+O", menuItem_Click, "frame speak");
menuFileOpenAgain = CreateMenuItem("Open Again", "Alt+O", menuItem_Click, "child speak");
menuFileRecent = CreateMenuItem("Recent Files ...", "Alt+R", menuItem_Click, "frame silent");
menuFileSetFavorite = CreateMenuItem("Set Favorite", "Control+&L", menuItem_Click, "child speak");
//menuFileSetFavorite = CreateMenuItem("Set on Favorite &List", "Control+L", menuItem_Click, "child speak");
menuFileClearFavorite = CreateMenuItem("Clear Favorite", "Control+Shift+L", menuItem_Click, "child speak");
menuFileListFavorites = CreateMenuItem("List Favorites ...", "Alt+L", menuItem_Click, "frame silent");
menuFileFind = CreateMenuItem("File Find ...", "Alt+Shift+F", menuItem_Click, "frame speak");
menuFileSave = CreateMenuItem("&Save", "Control+S", menuItem_Click, "child speak");
menuFileSaveAs = CreateMenuItem("Save &As ...", "Control+Shift+S", menuItem_Click, "child silent");
menuFileSaveCopy = CreateMenuItem("Save Copy ...", "Alt+Shift+S", menuItem_Click, "child speak");
menuFileExport = CreateMenuItem("Export Format ...", "Alt+Shift+E", menuItem_Click, "child silent");
menuFileRename = CreateMenuItem("Rename ...", "Alt+Shift+R", menuItem_Click, "child silent");
menuFileProperties = CreateMenuItem("Properties", "Alt+Enter", menuItem_Click, "child speak");
menuFileMailBody = CreateMenuItem("&Mail ...", "Control+M", menuItem_Click, "child speak");
menuFileMailAttach = CreateMenuItem("Mail as Attachment ...", "Control+Shift+M", menuItem_Click, "child speak");
menuFilePrint = CreateMenuItem("&Print", "Control+P", menuItem_Click, "child silent");
menuFileRun = CreateMenuItem("Run", "F5", menuItem_Click, "child speak");
menuFileCurrentWindows = CreateMenuItem("Current Windows ...", "F4", menuItem_Click, "frame silent");
menuFileClose = CreateMenuItem("&Close Window", "Control+F4", menuItem_Click, "child speak");
menuFileCloseAllButCurrentWindow = CreateMenuItem("Close All but Current Window", "Control+Shift+F4", menuItem_Click, "child speak");
menuFileExit = CreateMenuItem("&E&xit EdSharp", "Alt+F4", menuItem_Click, "frame speak");
menuFile.DropDownItems.AddRange(new ToolStripItem[] {menuFileNew, menuFileNewFromClipboard, menuFileOpen, menuFileOpenOtherFormat, menuFileOpenAgain, menuFileRecent, menuFileSetFavorite, menuFileClearFavorite, menuFileListFavorites, menuFileFind, menuFileSave, menuFileSaveAs, menuFileSaveCopy, menuFileExport, menuFileRename, menuFileProperties, menuFileMailBody, menuFileMailAttach, menuFilePrint, menuFileRun, menuFileCurrentWindows, menuFileClose, menuFileCloseAllButCurrentWindow, menuFileExit});
//Dialog.Show("File.", menuFile.DropDownItems.Count);

menuEdit = CreateMenu("&Edit");
menuEditSelectAll = CreateMenuItem("Select &All", "Control+A", menuItem_Click, "child speak");
menuEditUnselectAll = CreateMenuItem("Unselect All", "Control+Shift+A", menuItem_Click, "child speak");
menuEditCopy = CreateMenuItem("&Copy", "Control+C", menuItem_Click, "child speak");
menuEditCopyAppend = CreateMenuItem("Copy Append", "Alt+C", menuItem_Click, "child speak");
menuEditCut = CreateMenuItem("Cut", "Control+&X", menuItem_Click, "child speak");
menuEditCutAppend = CreateMenuItem("Cut Append", "Alt+X", menuItem_Click, "child speak");
menuEditPaste = CreateMenuItem("Paste", "Control+&V", menuItem_Click, "child speak");
menuEditPasteFile = CreateMenuItem("Paste File ...", "Control+Shift+V", menuItem_Click, "child speak");
menuEditUndo = CreateMenuItem("Undo", "Control+&Z", menuItem_Click, "child speak");
menuEditRedo = CreateMenuItem("Redo", "Control+Shift+Z", menuItem_Click, "child speak");
menuEditStartSelection = CreateMenuItem("Start Selection", "F8", menuItem_Click, "child speak");
menuEditCompleteSelection = CreateMenuItem("Complete Selection", "Shift+F8", menuItem_Click, "child speak");
menuEditReselect = CreateMenuItem("Reselect", "Control+Shift+F8", menuItem_Click, "child speak");
menuEditCopyAll = CreateMenuItem("Copy All", "Control+F8", menuItem_Click, "child speak");
menuEditSelectChunk = CreateMenuItem("Select Chunk", "Control+Space", menuItem_Click, "child silent");
menuEditQuote = CreateMenuItem("&Quote", "Control+Q", menuItem_Click, "child speak");
menuEditUnquote = CreateMenuItem("Unquote", "Control+Shift+Q", menuItem_Click, "child speak");
menuEditUpperCase = CreateMenuItem("&Upper Case", "Control+U", menuItem_Click, "child speak");
menuEditLowerCase = CreateMenuItem("Lower Case", "Control+Shift+U", menuItem_Click, "child speak");
menuEditProperCase = CreateMenuItem("Proper Case", "Alt+U", menuItem_Click, "child speak");
menuEditSwapCase = CreateMenuItem("Swap Case", "Alt+Shift+U", menuItem_Click, "child speak");
menuEditJoinLines = CreateMenuItem("Join Lines", "Control+Shift+J", menuItem_Click, "child speak");
menuEditHardLineBreak = CreateMenuItem("Hard Line Break ...", "Control+Shift+H", menuItem_Click, "child silent");
menuEditEnterNewLine = CreateMenuItem("Enter New Line", "Enter", menuItem_Click, "child silent");
menuEditIndentNewLine = CreateMenuItem("Indent New Line", "Shift+Enter", menuItem_Click, "child silent");
menuEditIndent = CreateMenuItem("Indent", "Tab", menuItem_Click, "child speak");
menuEditOutdent = CreateMenuItem("Outdent", "Shift+Tab", menuItem_Click, "child speak");
menuEditIndentMode = CreateMenuItem("Indent Mode", "Alt+Shift+I", menuItem_Click, "child speak");
menuEdit.DropDownItems.AddRange(new ToolStripItem[] {menuEditSelectAll, menuEditUnselectAll, menuEditCopy, menuEditCopyAppend, menuEditCut, menuEditCutAppend, menuEditPaste, menuEditPasteFile, menuEditUndo, menuEditRedo, menuEditStartSelection, menuEditCompleteSelection, menuEditReselect, menuEditCopyAll, menuEditSelectChunk, menuEditQuote, menuEditUnquote, menuEditUpperCase, menuEditLowerCase, menuEditProperCase, menuEditSwapCase, menuEditJoinLines, menuEditHardLineBreak, menuEditEnterNewLine, menuEditIndentNewLine, menuEditIndent, menuEditOutdent, menuEditIndentMode});
//Dialog.Show("Edit.", menuEdit.DropDownItems.Count);

menuDelete = CreateMenu("&Delete");
menuDeleteReplaceRegular = CreateMenuItem("&Replace ...", "Control+R", menuItem_Click, "child silent");
menuDeleteReplaceWithRegExp = CreateMenuItem("Replace with Regular Expression ...", "Control+Shift+R", menuItem_Click, "child silent");
menuDeleteLine = CreateMenuItem("Delete Line", "Alt+Back", menuItem_Click, "child silent");
menuDeleteRight = CreateMenuItem("Delete Right", "Control+Shift+Delete", menuItem_Click, "child silent");
menuDeleteLeft = CreateMenuItem("Delete Left", "Control+Shift+Back", menuItem_Click, "child silent");
menuDeleteDown = CreateMenuItem("Delete Down", "Alt+Shift+Delete", menuItem_Click, "child speak");
menuDeleteUp = CreateMenuItem("Delete Up", "Alt+Shift+Back", menuItem_Click, "child speak");
menuDeleteFile = CreateMenuItem("Delete File", "Alt+Shift+D", menuItem_Click, "child speak");
menuDeleteTrimBlanks = CreateMenuItem("TrimBlanks", "Control+Shift+Enter", menuItem_Click, "child speak");
menuDelete.DropDownItems.AddRange(new ToolStripMenuItem[] {menuDeleteReplaceRegular, menuDeleteReplaceWithRegExp, menuDeleteLine, menuDeleteRight, menuDeleteLeft, menuDeleteDown, menuDeleteUp, menuDeleteFile, menuDeleteTrimBlanks});
//Dialog.Show("Delete.", menuDelete.DropDownItems.Count);

menuNavigate = CreateMenu("&Navigate");
menuNavigateForwardFind = CreateMenuItem("Forward &Find ...", "Control+F", menuItem_Click, "child silent");
menuNavigateReverseFind = CreateMenuItem("Reverse Find ...", "Control+Shift+F", menuItem_Click, "child silent");
menuNavigateForwardFindAgain = CreateMenuItem("Forward Find Again", "F3", menuItem_Click, "child silent");
menuNavigateReverseFindAgain = CreateMenuItem("Reverse Find Again", "Shift+F3", menuItem_Click, "child silent");
menuNavigateJumpToLine = CreateMenuItem("&Jump to Line ...", "Control+J", menuItem_Click, "child silent");
menuNavigateJumpToLineAgain = CreateMenuItem("Jump to Line Again", "Alt+J", menuItem_Click, "child silent");
menuNavigateGoToPercent = CreateMenuItem("&Go to Percent ...", "Control+G", menuItem_Click, "child silent");
menuNavigateGoToPercentAgain = CreateMenuItem("Go to Percent Again", "Alt+G", menuItem_Click, "child silent");
menuNavigateSetBookmark = CreateMenuItem("Set Bookmar&k", "Control+K", menuItem_Click, "child speak");
menuNavigateClearBookmark = CreateMenuItem("Clear Bookmark", "Control+Shift+K", menuItem_Click, "child speak");
menuNavigateGoToBookmark = CreateMenuItem("Go to Bookmark", "Alt+K", menuItem_Click, "child speak");
menuNavigateHomeCharacter = CreateMenuItem("Home Character", "Alt+Home", menuItem_Click, "child silent");
menuNavigateEndCharacter = CreateMenuItem("End Character", "Alt+End", menuItem_Click, "child silent");
menuNavigateRightBrace = CreateMenuItem("Right Brace", "Control+B", menuItem_Click, "child silent");
menuNavigateLeftBrace = CreateMenuItem("Left Brace", "Control+Shift+B", menuItem_Click, "child silent");
menuNavigateNextBlock = CreateMenuItem("Next Indent", "Control+I", menuItem_Click, "child silent");
menuNavigatePriorBlock = CreateMenuItem("Prior Indent", "Control+Shift+I", menuItem_Click, "child silent");
menuNavigateNextChunk = CreateMenuItem("Next Chunk", "Alt+Right", menuItem_Click, "child silent");
menuNavigatePriorChunk = CreateMenuItem("Prior Chunk", "Alt+Left", menuItem_Click, "child silent");
menuNavigateNextSentence = CreateMenuItem("Next Sentence", "Alt+Down", menuItem_Click, "child silent");
menuNavigatePriorSentence = CreateMenuItem("Prior Sentence", "Alt+Up", menuItem_Click, "child silent");
menuNavigateNextParagraph = CreateMenuItem("Next Paragraph", "Control+Down", menuItem_Click, "child silent");
menuNavigatePriorParagraph = CreateMenuItem("Prior Paragraph", "Control+Up", menuItem_Click, "child silent");
menuNavigateNextPart= CreateMenuItem("Next Part", "Alt+PageDown", menuItem_Click, "child silent");
menuNavigatePriorPart= CreateMenuItem("Prior Part", "Alt+PageUp", menuItem_Click, "child silent");
menuNavigateNextSection= CreateMenuItem("Next Section", "Control+PageDown", menuItem_Click, "child silent");
menuNavigatePriorSection= CreateMenuItem("Prior Section", "Control+PageUp", menuItem_Click, "child silent");
menuNavigateGoToSection= CreateMenuItem("Go to Section", "F6", menuItem_Click, "child speak");
menuNavigateGoToContents = CreateMenuItem("Go to Contents", "Shift+F6", menuItem_Click, "child speak");
menuNavigateSearchForTopic = CreateMenuItem("Search for Topic ...", "Control+F6", menuItem_Click, "child silent");
menuNavigateSearchForTopicAgain = CreateMenuItem("Search for Topic Again", "Alt+F6", menuItem_Click, "child silent");
menuNavigateGoToStartOfSelection = CreateMenuItem("Go to Start of Selection", "Alt+Shift+F8", menuItem_Click, "child speak");
menuNavigate.DropDownItems.AddRange(new ToolStripItem[] {menuNavigateForwardFind, menuNavigateReverseFind, menuNavigateForwardFindAgain, menuNavigateReverseFindAgain, menuNavigateJumpToLine, menuNavigateJumpToLineAgain, menuNavigateGoToPercent, menuNavigateGoToPercentAgain, menuNavigateSetBookmark, menuNavigateClearBookmark, menuNavigateGoToBookmark, menuNavigateHomeCharacter, menuNavigateEndCharacter, menuNavigateRightBrace, menuNavigateLeftBrace, menuNavigateNextBlock, menuNavigatePriorBlock, menuNavigateNextChunk,  menuNavigatePriorChunk, menuNavigateNextSentence, menuNavigatePriorSentence, menuNavigateNextParagraph, menuNavigatePriorParagraph, menuNavigateNextPart, menuNavigatePriorPart, menuNavigateNextSection, menuNavigatePriorSection, menuNavigateGoToSection, menuNavigateGoToContents, menuNavigateSearchForTopic, menuNavigateSearchForTopicAgain, menuNavigateGoToStartOfSelection});
//Dialog.Show("Navigate.", menuNavigate.DropDownItems.Count);

menuQuery = CreateMenu("&Query");
menuQueryAddress = CreateMenuItem("Address", "Alt+A", menuItem_Click, "child silent");
menuQueryBraces = CreateMenuItem("Braces", "Alt+B", menuItem_Click, "child silent");
menuQueryIndent = CreateMenuItem("Indentation", "Alt+I", menuItem_Click, "child silent");
menuQueryPath = CreateMenuItem("Path", "Alt+P", menuItem_Click, "child speak");
menuQueryTopic = CreateMenuItem("Topic", "Alt+T", menuItem_Click, "child speak");
menuQueryYield = CreateMenuItem("Yield", "Alt+Y", menuItem_Click, "child speak");
menuQueryStatus = CreateMenuItem("Status", "Alt+Z", menuItem_Click, "child speak");
menuQuerySelected = CreateMenuItem("Selected", "Shift+Space", menuItem_Click, "child speak");
menuQueryChunk = CreateMenuItem("Chunk", "Shift+Back", menuItem_Click, "child speak");
menuQueryReadAll = CreateMenuItem("Read All", "Alt+F8", menuItem_Click, "child speak");
menuQueryWindowsOpen = CreateMenuItem("Windows Open", "Shift+F4", menuItem_Click, "child speak");
menuQueryClipboard = CreateMenuItem("Clipboard", "Alt+OemQuotes", menuItem_Click, "frame speak");
menuQueryTime = CreateMenuItem("Time", "Alt+OemSemicolon", menuItem_Click, "frame speak");
menuQuery.DropDownItems.AddRange(new ToolStripItem[] {menuQueryAddress, menuQueryBraces, menuQueryIndent, menuQueryPath, menuQueryTopic, menuQueryYield, menuQueryStatus, menuQuerySelected, menuQueryChunk, menuQueryReadAll, menuQueryWindowsOpen, menuQueryClipboard, menuQueryTime});
//Dialog.Show("Query.", menuQuery.DropDownItems.Count);

menuMisc = CreateMenu("&Misc");
menuMiscSetFontAndColor = CreateMenuItem("Set Font and Color ...", "Alt+Shift+OemMinus", menuItem_Click, "frame silent");
menuMiscConfigurationOptions = CreateMenuItem("Configuration Options ...", "Alt+Shift+C", menuItem_Click, "frame silent");
menuMiscManualOptions = CreateMenuItem("Manual Options", "Alt+Shift+M", menuItem_Click, "frame speak");
menuMiscWordWrap = CreateMenuItem("&Word Wrap", "Control+W", menuItem_Click, "child speak");
menuMiscUnwrap = CreateMenuItem("Unwrap", "Control+Shift+W", menuItem_Click, "child speak");
menuMiscSpellCheck = CreateMenuItem("Spell Check", "F7", menuItem_Click, "child speak");
menuMiscThesaurus = CreateMenuItem("Thesaurus", "Shift+F7", menuItem_Click, "child speak");
menuMiscDictionary = CreateMenuItem("Dictionary", "Alt+F7", menuItem_Click, "child silent");
menuMiscGuardDocument = CreateMenuItem("Guard Document", "Control+F7", menuItem_Click, "child speak");
menuMiscNoGuard = CreateMenuItem("No Guard", "Control+Shift+F7", menuItem_Click, "child speak");
menuMiscRepeatLine = CreateMenuItem("Repeat Line", "Control+Y", menuItem_Click, "child speak");
menuMiscSectionBreak = CreateMenuItem("Section Break", "Control+Enter", menuItem_Click, "child speak");
menuMiscPathToClipboard = CreateMenuItem("Path to Clipboard", "Alt+Shift+P", menuItem_Click, "child speak");
menuMiscPathList = CreateMenuItem("Path List", "Control+Shift+P", menuItem_Click, "child speak");
menuMiscInsertTime = CreateMenuItem("Insert Time", "Alt+Shift+OemSemicolon", menuItem_Click, "child speak");
menuMiscCalculateDate = CreateMenuItem("Calculate Date ...", "Control+Shift+OemSemicolon", menuItem_Click, "child silent");
menuMiscHTMLFormat = CreateMenuItem("&Html Format", "Control+H", menuItem_Click, "child speak");
menuMiscTextConvert = CreateMenuItem("&Text Convert", "Control+T", menuItem_Click, "child speak");
menuMiscTextCombine = CreateMenuItem("Text Combine", "Control+Shift+T", menuItem_Click, "child speak");
menuMiscTextContents = CreateMenuItem("Text Contents", "Alt+Shift+T", menuItem_Click, "child speak");
menuMiscYieldWithRegExp = CreateMenuItem("Yield with Regular Expression ...", "Control+Shift+Y", menuItem_Click, "child silent");
//menuMiscYieldWithRegExp.ShortcutKeys = Util.String2Key("Control+Shift+Y");
menuMiscExtractWithRegExp = CreateMenuItem("Extract with Regular Expression ...", "Control+Shift+E", menuItem_Click, "child silent");
menuMiscRunAtCursor = CreateMenuItem("Run at Cursor ...", "Shift+F5", menuItem_Click, "child silent");
menuMiscEvaluateExpression = CreateMenuItem("Evaluate Expression", "Control+Oemplus", menuItem_Click, "child silent");
menuMiscCompile = CreateMenuItem("Compile", "Control+F5", menuItem_Click, "child speak");
menuMiscPickCompiler = CreateMenuItem("Pick Compiler", "Control+Shift+F5", menuItem_Click, "child silent");
menuMiscKeepUniqueLines = CreateMenuItem("Keep Unique Lines", "Alt+Shift+K", menuItem_Click, "child speak");
menuMiscNumberLines = CreateMenuItem("Number Lines ...", "Alt+Shift+N", menuItem_Click, "child silent");
menuMiscOrderLines = CreateMenuItem("Order Lines", "Alt+Shift+O", menuItem_Click, "child speak");
menuMiscReverseLines = CreateMenuItem("Reverse Lines", "Alt+Shift+Z", menuItem_Click, "child speak");
menuMiscListDifferentLines = CreateMenuItem("List Different Lines", "Alt+Shift+L", menuItem_Click, "child speak");
menuMiscQueryCommonLines = CreateMenuItem("Query Common Lines", "Alt+Shift+Q", menuItem_Click, "child speak");
menuMiscExplorerFolder = CreateMenuItem("Explorer Folder", "Alt+Oem5", menuItem_Click, "child speak");
menuMiscCommandPrompt = CreateMenuItem("Command Prompt", "Control+Oem5", menuItem_Click, "child speak");
menuMisc.DropDownItems.AddRange(new ToolStripItem[] {menuMiscSetFontAndColor, menuMiscConfigurationOptions, menuMiscManualOptions, menuMiscWordWrap, menuMiscUnwrap, menuMiscSpellCheck, menuMiscThesaurus, menuMiscDictionary, menuMiscGuardDocument, menuMiscNoGuard, menuMiscRepeatLine, menuMiscSectionBreak, menuMiscPathToClipboard, menuMiscPathList, menuMiscInsertTime, menuMiscCalculateDate, menuMiscHTMLFormat, menuMiscTextConvert, menuMiscTextCombine, menuMiscTextContents, menuMiscYieldWithRegExp, menuMiscExtractWithRegExp, menuMiscRunAtCursor, menuMiscEvaluateExpression, menuMiscCompile, menuMiscPickCompiler, menuMiscKeepUniqueLines, menuMiscNumberLines, menuMiscOrderLines, menuMiscReverseLines, menuMiscListDifferentLines, menuMiscQueryCommonLines, menuMiscExplorerFolder, menuMiscCommandPrompt});
//Dialog.Show("Misc.", menuMisc.DropDownItems.Count);

menuWindow = CreateMenu("&Window");
menuWindowNext = CreateMenuItem("Next Window", "Control+Tab", menuItem_Click, "child speak");
menuWindowPrior = CreateMenuItem("Prior Window", "Control+Shift+Tab", menuItem_Click, "child speak");
menuWindow.DropDownItems.AddRange(new ToolStripMenuItem[] {menuWindowNext, menuWindowPrior});
//Dialog.Show("Window.", menuWindow.DropDownItems.Count);

menuHelp = CreateMenu("&Help");
menuHelpAbout = CreateMenuItem("&About ...", "Alt+F1", menuItem_Click, "frame silent");
menuHelpDocumentation = CreateMenuItem("Documentation", "F1", menuItem_Click, "frame speak");
menuHelpHistoryOfChanges = CreateMenuItem("History of Changes", "Shift+F1", menuItem_Click, "frame speak");
menuHelpHotKeySummary = CreateMenuItem("HotKeySummary", "Alt+Shift+H", menuItem_Click, "frame speak");
menuHelpAlternateMenu= CreateMenuItem("Alternate Menu ...", "Alt+F10", menuItem_Click, "frame silent");
menuHelpContextMenu= CreateMenuItem("Context Menu ...", "Shift+F10", menuItem_Click, "child silent");
menuHelpSendToMenu= CreateMenuItem("SendTo Menu ...", "Control+F10", menuItem_Click, "child silent");
menuHelpElevateVersion = CreateMenuItem("Elevate Version", "F11", menuItem_Click, "frame speak");
menuHelp.DropDownItems.AddRange(new ToolStripItem[] {menuHelpAbout, menuHelpDocumentation, menuHelpHistoryOfChanges, menuHelpHotKeySummary, menuHelpAlternateMenu, menuHelpContextMenu, menuHelpSendToMenu, menuHelpElevateVersion});
//Dialog.Show("Help.", menuHelp.DropDownItems.Count);

menuMain.Items.AddRange(new ToolStripItem[] {menuFile, menuEdit, menuDelete, menuNavigate, menuQuery, menuMisc, menuWindow, menuHelp});
//menuMain.Items.AddRange(new ToolStripItem[] {menuFile, menuEdit, menuDelete, menuNavigate, menuQuery, menuMisc, menuHelp});
statusBar = CreateStatusBar();
this.Controls.AddRange(new Control[] {menuMain, statusBar});
this.MainMenuStrip = menuMain;
menuMain.MdiWindowListItem = menuWindow;
//this.AutoSize = true;
this.Size = new Size(600, 600);
this.StartPosition = FormStartPosition.CenterScreen;
this.Text = "EdSharp";
this.ResumeLayout();
this.KeyPreview = true;
//this.MdiChildActivate += delegate(object o, EventArgs e) {this.Child = (MdiChild) this.ActiveMdiChild;};
string s = App.ReadOption("MaximizeStartUp", "N").Trim().ToUpper();
//if (s == "Y" || s == "YES") this.Shown += delegate(object o, EventArgs e) {this.WindowState = FormWindowState.Maximized;};
if (s == "Y" || s == "YES") this.Shown += delegate(object o, EventArgs e) {this.WindowState = FormWindowState.Maximized; this.Activate(); Win32.SetForegroundWindow(this.Handle);};
} // MdiFrame constructor

public void SetStatus(object o) {
string sText = o.ToString();
this.statusBar.Items[0].Text = sText;
} // SetStatus method

public string GetNoNameTitle() {
object[] children = this.MdiChildren;
List<int> list = new List<int>();
foreach (object o in children) {
MdiChild child = (MdiChild) o;
string sTitle = child.Text;
if (sTitle.StartsWith("NoName") && Path.GetExtension(sTitle).Length == 0) {
string s = sTitle.Substring(6);
int i = Int32.Parse(s);
list.Add(i);
}
}

int iTitle = 0;
for (int i = 1; i <= children.Length; i++) {
if (!list.Contains(i)) {
iTitle = i;
break;
}
}

if (iTitle == 0) iTitle = children.Length + 1;
string sReturn = "NoName" + iTitle.ToString();
return sReturn;
} // GetNoNameTitle

public bool ProcessCmdKey_Helper(ref Message msg, Keys keyData) {
ToolStripMenuItem menuItem;
if (hashKey.TryGetValue(keyData, out menuItem)) {
//if (this.Child != null && !this.Child.RTB.IndentMode && menuItem == menuEditEnterNewLine) return base.ProcessCmdKey (ref msg, keyData);
this.bCommandComplete = false;
menuItem.PerformClick();
this.bCommandComplete = true;
return true;
}
else return base.ProcessCmdKey (ref msg, keyData);
} // ProcessCmdKey_Helper method

protected override bool ProcessCmdKey(ref Message msg, Keys keyData) {
return this.ProcessCmdKey_Helper(ref msg, keyData);
} // ProcessCmdKey handler

static MenuStrip CreateMainMenu() {
MenuStrip menuMain = new MenuStrip();
menuMain.AccessibleRole = AccessibleRole.MenuBar;
//menuMain.AutoSize = true;
//menuMain.CanOverflow = false;
menuMain.Dock = DockStyle.Top;
//menuMain.LayoutStyle = ToolStripLayoutStyle.Flow;
//menuMain.Stretch = false;
return menuMain;
} // CreateMainMenu method

static ToolStripMenuItem CreateMenu(string sText) {
ToolStripMenuItem menuItem = new ToolStripMenuItem(sText);
menuItem.AccessibleRole = AccessibleRole.MenuItem;
return menuItem;
} // CreateMenu method

static ToolStripMenuItem CreateMenuItem(string sText, string sKey, EventHandler eh) {
bool bFrame = false;
return CreateMenuItem(sText, sKey, eh, bFrame);
} // CreateMenuItem method

static ToolStripMenuItem CreateMenuItem(string sText, string sKey, EventHandler eh, bool bFrame) {
string sOptions = "";
if (bFrame) sOptions += "frame ";
if (sText.EndsWith(" ...") || sText.EndsWith("Again")) sOptions += "silent ";
return CreateMenuItem(sText, sKey, eh, sOptions);
}  // CreateMenuItem method

static ToolStripMenuItem CreateMenuItem(string sText, string sKey, EventHandler eh, string sOptions) {
ToolStripMenuItem menuItem = new ToolStripMenuItem(sText, null, eh);
menuItem.AccessibleRole = AccessibleRole.MenuItem;
menuItem.Tag = sOptions;

string sCommand = sText.Replace("&", "").Replace("...", "").Trim();
menuItem.Name = sCommand;
//Ini.WriteValue(@"c:\temp\temp.ini", "Keys", sCommand, sKey);
string s = Ini.ReadValue(App.IniFile, "Keys", sCommand, "").Trim();
if (!Util.Equiv(s, "None")) {
if (s.Length > 0) sKey = s;
sKey = sKey.Replace("&", "");
Keys keyData = Util.String2Key(sKey);
if (hashKey.ContainsKey(keyData)) {
s = hashKey[keyData].Text.Split('\t')[0].Replace("&", "").Replace("...", "").Trim();
Dialog.Show("Alert", "Cannot assign " + sKey + " to " + sCommand + ",\nsince already assigned to " + s);
}
else {
sText += "\t" + Util.GetFriendlyKeyName(sKey);
menuItem.Text = sText;
hashKey.Add(keyData, menuItem);
}
}
return menuItem;
} // CreateMenuItem method

static StatusStrip CreateStatusBar() {
StatusStrip sb = new StatusStrip();
sb.AccessibleRole = AccessibleRole.StatusBar;
sb.SuspendLayout();
ToolStripStatusLabel lblStatus = new ToolStripStatusLabel("Ready");
lblStatus.AutoSize = true;
sb.Items.AddRange(new ToolStripItem[] {lblStatus});
sb.AutoSize = true;
sb.Dock = DockStyle.Bottom;
sb.ResumeLayout();
return sb;
} // CreateStatusBar method

public void SetStatusAddress(object sender, EventArgs e) {
if (sender != null && !this.bCommandComplete) return;
if (this.Child == null) {
SetStatus("");
return;
}

HomerRichTextBox rtb = this.Child.RTB;
string sText = String.Format("Line {0}\tColumn {1}\tPercent{2}", rtb.Line, rtb.Column, rtb.Percent);
if (sender == null) Util.Say(sText);
this.SetStatus(sText);

if (!rtb.IndentMode) return;
string sLine = rtb.RowText.Trim();
if (sLine.Length == 0) return;
string sComment = App.ReadOption("QuotePrefix", "> ");
if (sLine.StartsWith(sComment)) return;
int iLevels = GetIndent();
if (rtb.IndentLevels == iLevels) return;
Util.Say(GetDelta(rtb.IndentLevels, iLevels));
rtb.IndentLevels = iLevels;
} // SetStatusAddress method

public void AddMessage(object oText) {
string sText = oText.ToString();
Util.Say(sText);
sText = this.statusBar.Items[0].Text + "\t" + sText;
SetStatus(sText);
} // AddMessage method

public void SetMessage(object oText) {
SetStatus(oText);
Util.Say(oText);
} // SetMessage method

public void GetRowAndCol(out int iRow, out int iCol) {
HomerRichTextBox rtb = this.Child.RTB;
int iIndex = rtb.SelectionStart + rtb.SelectionLength;
iRow = rtb.GetLineFromCharIndex(iIndex);
iCol = iIndex - rtb.GetFirstCharIndexOfCurrentLine();
} // GetRowAndCol method

bool IsEmptyWindow() {
return !(this.Child == null || this.Child.RTB.Modified || this.Child.RTB.TextLength > 0);
} // IsEmptyWindow method

public bool IsCharacter() {
int iIndex;
return IsCharacter(out iIndex);
} // IsCharacter method

public bool IsCharacter(out int iIndex) {
HomerRichTextBox rtb = this.Child.RTB;
iIndex = rtb.Index;
if (iIndex >= rtb.TextLength) {
AddMessage("No character at cursor!");
return false;
}
else return true;
} // IsCharacter method

public int GetIndent() {
string sIndent = App.ReadOption("IndentUnit", "  ");
sIndent = Util.Literalize(sIndent);
MdiChild child = this.Child;
HomerRichTextBox rtb = child.RTB;
string sLine = rtb.RowText;
int iLength = sIndent.Length;
int iLevels = 0;
while (sLine.StartsWith(sIndent)) {
iLevels++;
if (sLine.Length == iLength) sLine = "";
else sLine = sLine.Substring(iLength);
}
return iLevels;
} // GetIndent method

public string GetDelta(int iBefore, int iAfter) {
if (iBefore < iAfter) return "In " + (iAfter - iBefore);
else return "Out " + (iBefore - iAfter);
} // GetDelta method

public void menuItem_Click(object sender, EventArgs e) {
//Util.Beep();
HomerRichTextBox rtb = null;
string[] aLabels, aValues, aResults;
bool bSelected;
int iLength, iStart, iEnd, iResult, iIndex, iLine, iPercent, iCount;
string sFile, sMatch, sReplace, sPattern, sSubstitute, sLine, sTitle, sText, sResult, sLabel, sValue;

ToolStripMenuItem menuItem = (ToolStripMenuItem) sender;
string sOptions = (string) menuItem.Tag;
sOptions = " " + sOptions.Trim().ToLower() + " ";
sLabel = menuItem.Text.Replace("&", "").Replace(" ...", "").Split('\t')[0];
if (sOptions.Contains(" silent ")) SetStatus(sLabel);
else SetMessage(sLabel);

MdiChild child = this.Child;
if (child == null) {
if (!sOptions.Contains(" frame ")) return;
}
else {
rtb = Child.RTB;
}

if (menuItem == menuFileNew) {
child = new MdiChild(App.Frame);
}

if (menuItem == menuFileNewFromClipboard) {
child = new MdiChild(App.Frame);
Child.RTB.Text = Clipboard.GetText();
}

if (menuItem == menuFileOpen) {
sFile = Dialog.OpenFile("", "");
if (sFile.Length == 0) return;
OpenOrActivateWindow(sFile, 0);
}

if (menuItem == menuFileOpenOtherFormat) {
sFile = Dialog.OpenFile("", "");
if (sFile.Length == 0) return;

OpenOrActivateWindow(sFile, 2);
return;
/*
AddMessage("Converting");
try {
sText = COM.ConvertFile2String(sFile);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}

if (!IsEmptyWindow()) new MdiChild(this);
child = this.Child;
rtb = child.RTB;
rtb.Text = sText;
rtb.Index = 0;
child.Text = Path.GetFileNameWithoutExtension(sFile) + ".txt";
//rtb.Modified = true;
rtb.Modified = false;
//AddMessage("Done!");
*/
}

if (menuItem == menuFileOpenAgain) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

iIndex = rtb.Index;
if (Dialog.Confirm("Confirm", "Existing text will be  replaced.  Sure?", "Y") != "Y") return;
child.LoadTextFile(sFile);
rtb.Index = iIndex;
}

if (menuItem == menuFileRecent) {
aResults = App.ReadSectionKeys("Recent");
List<string> list = new List<string>(aResults);
for (int i = list.Count - 1; i >=0; i--) {
string s = list[i];
if (File.Exists(s)) continue;
App.DeleteKey("Recent", s);
list.RemoveAt(i);
}

aResults = list.ToArray();
if (aResults.Length == 0) {
AddMessage("No items!");
return;
}

string[] aTime = new string[aResults.Length];
for (int i = 0; i < aTime.Length; i++) aTime[i] = App.ReadValue("Recent", aResults[i], "");
Array.Reverse(aTime);
Array.Sort(aTime, aResults);

string[] aDisplay = new string[aResults.Length];
for (int i = 0; i < aDisplay.Length; i++) aDisplay[i] = Path.GetFileName(aResults[i]);

sFile = Dialog.Pick("Recent Files", aResults, aDisplay, false, 0);
if (sFile.Length == 0) return;
OpenOrActivateWindow(sFile, 1);
}

if (menuItem == menuFileFind) {
FileFind();
}

if (menuItem == menuFileSaveCopy) {
AddMessage("Save Copy");
sFile = child.File + ".bak";
sFile = Dialog.SaveFile("", sFile);
if (sFile.Length == 0) return;
rtb.SaveFile(sFile, RichTextBoxStreamType.PlainText);
}

if ((menuItem == menuFileSave) || (menuItem == menuFileSaveAs)) {
sFile = child.File;
if ((menuItem == menuFileSave) && sFile.Contains(@"\")) sText = "";//AddMessage("Save");
else {
sFile = Dialog.SaveFile("", sFile);
if (sFile.Length == 0) return;
}

//Dialog.Show(sFile);
//if (Path.GetExtension(sFile).Length == 0) sFile += ".txt";
child.SaveTextFile(sFile);
//Ini.FlushFile(App.IniFile);
//if (sFile == App.IniFile) rtb.Modified = false;
rtb.Modified = false;
}

if (menuItem == menuFileExport) {
sFile = child.File;
aValues = Ini.ReadSectionKeys(App.IniFile, "Export");
List<string> list = new List<string>(aValues);
for (int i = 0; i < list.Count; i++) list[i] = list[i].ToLower();
aValues = new string[] {"doc", "htm", "rtf", "xml"};
foreach (string s in aValues) if (!list.Contains(s)) list.Add(s);
aValues = list.ToArray();
if (aValues.Length == 0) {
AddMessage("No export formats available!");
return;
}

sResult = Dialog.Pick("Export Format", aValues, true, 0);
if (sResult.Length == 0) return;
sFile = Path.ChangeExtension(sFile, sResult);
sFile = Dialog.SaveFile("", sFile);
if (sFile.Length == 0) return;

string sExt = sResult.ToLower();
switch (sExt) {
case "rtf" :
rtb.SaveFile(sFile, RichTextBoxStreamType.RichText);
break;
default :
sText = rtb.Text;
string s = Path.GetExtension(child.File);
Util.ConvertString2FileFormat(sText, s, sFile, sExt);
break;
}
if (File.Exists(sFile)) AddMessage("Done!");
else AddMessage("Error!");
}

if (menuItem == menuFileRename) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

string sName = Dialog.Input("Rename", "File Name", child.Text).Trim();
if (sName.Length == 0) return;

string sNewFile = Path.Combine(Path.GetDirectoryName(sFile), sName);
try {
File.Move(sFile, sNewFile);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}
child.Text = sName;
child.File = sNewFile;
}

if (menuItem == menuFileMailBody) {
try {
sText = rtb.Text;
sText = Util.Convert2WinLineBreak(sText);
sText = Util.RegExpReplaceCase(sText, "\r\n", "%0D%0A");
sText = Util.RegExpReplaceCase(sText, " ", "%20");
sText = Util.RegExpReplaceCase(sText, "\t", "%09");
sText = Util.RegExpReplaceCase(sText, "\"", "%22");
sText = Util.RegExpReplaceCase(sText, "'", "%27");
sText = Util.RegExpReplaceCase(sText, "\\\\", "%5C");
string sCommand = "mailto:?BODY=" + sText;
Process.Start(sCommand);
}
catch {
Mail(false);
}
}

if (menuItem == menuFileMailAttach) {
Mail(true);
}

if (menuItem == menuFileRun) {
sFile = child.File;
if (!sFile.Contains(@"\") || rtb.Modified) {
sFile = Path.Combine(Path.GetTempPath(), Path.GetFileName(sFile));
sText = rtb.Text;
Util.String2File(sText, sFile);
}

Process.Start(sFile);
}

if (menuItem == menuFilePrint) {
sFile = child.File;
sFile = Path.GetFileName(sFile);
if (Dialog.Confirm("Confirm", "Print " + sFile + "?", "Y") != "Y") return;

sFile = Path.Combine(Path.GetTempPath(), sFile);
sText = rtb.Text;
sText = Util.Convert2WinLineBreak(sText);
Util.String2File(sText, sFile);
string sCommand = "Notepad.exe /p " + Util.Quote(sFile);
Util.RunHideWait(sCommand);
File.Delete(sFile);
}

if (menuItem == menuFileProperties) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

Dialog.Properties(sFile);
}

if (menuItem == menuFileCurrentWindows) {
CurrentWindows();
}

if (menuItem == menuFileClose) {
CloseWindow(child);
}

if (menuItem == menuFileCloseAllButCurrentWindow) {
CloseAllButCurrentWindow();
}

if (menuItem == menuFileExit) {
ExitApp();
}

if (menuItem == menuEditSelectAll) {
rtb.SelectAll();
iCount = rtb.SelectedText.Length;
AddMessage(Util.Pluralize(iCount, "character"));
}

if (menuItem == menuEditUnselectAll) {
rtb.DeselectAll();
iIndex = rtb.Index;
if (iIndex >= rtb.TextLength) return;
sText = rtb.GetRange(rtb.Index, rtb.Index + 1);
AddMessage(sText);
}

if (menuItem == menuEditCopy) {
if (rtb.SelectionLength == 0) {
AddMessage("Line");
sText = rtb.RowText + LineBreak;
}
else {
AddMessage("Selected");
sText = rtb.SelectedText;
rtb.StoreSelection();
}
Clipboard.SetText(sText);
}

if (menuItem == menuEditCopyAppend) {
sText = Clipboard.GetText();
if (sText.Length > 0 && !sText.EndsWith(LineBreak)) sText += LineBreak;
if (rtb.SelectionLength == 0) {
AddMessage("Line");
sText += rtb.RowText + LineBreak;
}
else {
AddMessage("Selected");
sText += rtb.SelectedText;
rtb.StoreSelection();
}
Clipboard.SetText(sText);
}

if (menuItem == menuEditCut) {
if (rtb.SelectionLength == 0) {
AddMessage("Line");
sText = rtb.RowText + LineBreak;
rtb.Select(rtb.RowStart, rtb.RowLength);
}
else {
AddMessage("Selected");
sText = rtb.SelectedText;
}
rtb.Cut();
Clipboard.SetText(sText);
}

if (menuItem == menuEditCutAppend) {
sText = Clipboard.GetText();
if (sText.Length > 0 && !sText.EndsWith(LineBreak)) sText += LineBreak;
if (rtb.SelectionLength == 0) {
AddMessage("Line");
sText += rtb.RowText + LineBreak;
rtb.Select(rtb.RowStart, rtb.RowLength);
}
else {
AddMessage("Selected");
sText += rtb.SelectedText;
}
rtb.Cut();
Clipboard.SetText(sText);
}

if (menuItem == menuEditPaste) {
rtb.Paste();
}

if (menuItem == menuEditPasteFile) {
sFile = Dialog.OpenFile("", "");
if (sFile.Length == 0) return;
sText = Util.File2String(sFile);
sText = sText.Trim() + LB;
iIndex = rtb.Index;
rtb.ReplaceRange(iIndex, iIndex, sText);
rtb.Index = iIndex;
AddMessage(rtb.RowText);
}

if (menuItem == menuEditUndo) {
rtb.Undo();
}

if (menuItem == menuEditRedo) {
rtb.Redo();
}

if (menuItem == menuEditStartSelection) {
if (!IsCharacter(out iIndex)) return;

rtb.StartSelection = iIndex;
sText = rtb.GetRange(rtb.Index, rtb.Index + 1);
AddMessage(sText);
}

if (menuItem == menuEditCompleteSelection) {
rtb.SelectRange(rtb.StartSelection, rtb.Index);
iCount = rtb.SelectedText.Length;
AddMessage(Util.Pluralize(iCount, "character"));
}

if (menuItem == menuEditReselect) {
rtb.Reselect();
}

if (menuItem == menuEditCopyAll) {
Clipboard.SetText(rtb.Text);
}

if (menuItem == menuEditSelectChunk) {
bool bLoop = false;
string c = "";
object[] a = GetChunk();
iStart = (int) a[0];
iIndex = iStart;
sText = rtb.Text;
if (rtb.SelectionLength == 0) {
AddMessage("Select Chunk");
}
else {
iStart = rtb.SelectionStart;
bLoop = iIndex < sText.Length;
while (bLoop) {
c = sText.Substring(iIndex, 1);
bLoop = (c.Trim().Length == 0);
iIndex++;
bLoop = (bLoop && iIndex < sText.Length);
}
}

bLoop = iIndex < sText.Length;
while (bLoop) {
c = sText.Substring(iIndex, 1);
bLoop = (c.Trim().Length > 0);
iIndex++;
bLoop = (bLoop && iIndex < sText.Length);
}
iEnd = iIndex;
rtb.SelectRange(iStart, iEnd);
}

if (menuItem == menuEditQuote) {
//if (!IsCharacter(out iIndex)) return;

string sPrefix = App.ReadOption("QuotePrefix", "> ");
if (rtb.SelectionLength == 0) {
AddMessage("Line");
iStart = rtb.RowStart;
iEnd = iStart + rtb.RowLength;
//Dialog.Show(iStart, iEnd);
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
sText = Util.RegExpReplaceCase(sText, "^", sPrefix);
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
AddMessage(rtb.RowText);
}

if (menuItem == menuEditUnquote) {
string sPrefix = App.ReadOption("QuotePrefix", "> ");
if (rtb.SelectionLength == 0) {
AddMessage("Line");
iStart = rtb.RowStart;
iEnd = iStart + rtb.RowLength;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
//sText = Util.RegExpReplaceCase(sText, @"^( |\t|\>)+", "");
sText = Util.RegExpReplaceCase(sText, @"^" + sPrefix, "");
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
AddMessage(rtb.RowText);
}

if (menuItem == menuEditUpperCase) {
if (rtb.SelectionLength == 0) {
AddMessage("Character");
iStart = rtb.Index;
iEnd = iStart + 1;
bSelected = false;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
bSelected = true;
}

sText = rtb.GetRange(iStart, iEnd);
sText = sText.ToUpper();
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
if (bSelected) sText = rtb.RowText;
else sText = rtb.GetRange(rtb.Index, rtb.Index + 1);
AddMessage(sText);
}

if (menuItem == menuEditLowerCase) {
if (rtb.SelectionLength == 0) {
AddMessage("Character");
iStart = rtb.Index;
iEnd = iStart + 1;
bSelected = false;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
bSelected = true;
}

sText = rtb.GetRange(iStart, iEnd);
sText = sText.ToLower();
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
if (bSelected) sText = rtb.RowText;
else sText = rtb.GetRange(rtb.Index, rtb.Index + 1);
AddMessage(sText);
}

if (menuItem == menuEditProperCase) {
if (rtb.SelectionLength == 0) {
AddMessage("Character");
iStart = rtb.Index;
iEnd = iStart + 1;
bSelected = false;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
bSelected = true;
}

sText = rtb.GetRange(iStart, iEnd);
sText = Util.ProperCase(sText);
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
if (bSelected) sText = rtb.RowText;
else sText = rtb.GetRange(rtb.Index, rtb.Index + 1);
AddMessage(sText);
}

if (menuItem == menuEditSwapCase) {
if (rtb.SelectionLength == 0) {
AddMessage("Character");
iStart = rtb.Index;
iEnd = iStart + 1;
bSelected = false;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
bSelected = true;
}

sText = rtb.GetRange(iStart, iEnd);
sText = Util.SwapCase(sText);
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
if (bSelected) sText = rtb.RowText;
else sText = rtb.GetRange(rtb.Index, rtb.Index + 1);
AddMessage(sText);
}

if (menuItem == menuEditJoinLines) {
if (rtb.SelectionLength == 0) {
AddMessage("All");
iStart = 0;
iEnd = rtb.TextLength;
}
else {
AddMessage("Selected");
iStart = rtb.Index;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
sText = Util.RegExpReplaceCase(sText, @" +\n", "\n");
sText = Util.RegExpReplaceCase(sText, "([^\n])\n([^\n])", "$1 $2");
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart + sText.Length;
AddMessage(rtb.RowText);
}

if (menuItem == menuEditHardLineBreak) {
HardLineBreak();
}

if (menuItem == menuEditEnterNewLine|| menuItem == menuEditIndentNewLine) {
SetStatus("");
if ((!rtb.IndentMode && menuItem == menuEditEnterNewLine) || (rtb.IndentMode && menuItem == menuEditIndentNewLine)) {
SetStatus("Enter New Line");
sText = "\n";
iIndex = rtb.Index;
rtb.ReplaceRange(iIndex, iIndex, sText);
rtb.Index = iIndex + sText.Length;
}
else {
SetStatus("Indent New Line");
sText = rtb.RowText;
iIndex = rtb.RowStart + sText.Length;
sMatch = @"^(\s*).*";
sReplace = "$1";
sText = Util.RegExpReplaceCase(sText, sMatch, sReplace);
sText = "\n" + sText;
rtb.ReplaceRange(iIndex, iIndex, sText);
rtb.Index = iIndex + sText.Length;
AddMessage(Util.Pluralize(this.GetIndent(), "level"));
AddMessage(rtb.RowText);
}
}

if (menuItem == menuEditIndent) {
string sIndent = App.ReadOption("IndentUnit", "  ");
sIndent = Util.Literalize(sIndent);
iIndex = rtb.Index;
if (rtb.SelectionLength == 0) {
AddMessage("Line");
iStart = rtb.RowStart;
iEnd = iStart + rtb.RowLength;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
sText = Util.RegExpReplaceCase(sText, "^", sIndent);
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iIndex + sIndent.Length;
AddMessage(Util.Pluralize(this.GetIndent(), "level"));
//AddMessage(rtb.RowText);
}

if (menuItem == menuEditOutdent) {
string sIndent = App.ReadOption("IndentUnit", "  ");
sIndent = Util.Literalize(sIndent);
iIndex = rtb.Index;
if (rtb.SelectionLength == 0) {
AddMessage("Line");
iStart = rtb.RowStart;
iEnd = iStart + rtb.RowLength;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
iLength = sText.Length;
sText = Util.RegExpReplaceCase(sText, "^" + sIndent, "");
rtb.ReplaceRange(iStart, iEnd, sText);
if (sText.Length < iLength) rtb.Index = iIndex - sIndent.Length;
AddMessage(Util.Pluralize(this.GetIndent(), "level"));
//AddMessage(rtb.RowText);
}

if (menuItem == menuEditIndentMode) {
rtb.IndentMode = !rtb.IndentMode;
AddMessage(rtb.IndentMode ? "On" : "Off");
//return;
}

if (menuItem == menuMiscSpellCheck) {
SpellCheck();
}

if (menuItem == menuMiscThesaurus) {
Thesaurus();
}

if (menuItem == menuMiscDictionary) {
sValue = App.ReadData("Define", "");
sResult = Dialog.Input("Dictionary", "Define", sValue).Trim();
if (sResult.Length == 0) return;

App.WriteData("Define", sResult);
//AddMessage("Please wait");
AddMessage("Connecting to dictionary.com");
sText = VB.Dictionary(sResult);
if (!IsEmptyWindow()) new MdiChild(this);
child = this.Child;
child.Text = sResult + ".txt";
child.File = child.Text;
rtb = child.RTB;
rtb.Text = sText;
}

if (menuItem == menuMiscGuardDocument) {
rtb.SetGuard(true);
SetRecent(child.File);
}

if (menuItem == menuMiscNoGuard) {
rtb.SetGuard(false);
SetRecent(child.File);
}

if (menuItem == menuMiscRepeatLine) {
sText = CR + rtb.RowText;
iIndex = rtb.RowStart + rtb.RowText.Length;
rtb.ReplaceRange(iIndex, iIndex, sText);
rtb.Index = iIndex + 1;
AddMessage(rtb.RowText);
}

if (menuItem == menuMiscSectionBreak) {
rtb.ReplaceRange(rtb.Index, rtb.Index, SectionBreak);
AddMessage(rtb.RowText);
}

if (menuItem == menuDeleteReplaceRegular) {
if (rtb.SelectionLength == 0) {
sTitle = "Replace All";
iStart = 0;
iEnd = rtb.TextLength;
}
else {
sTitle = "Replace Selected";
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

aLabels = new string[] {"&Match", "&Replace"};
sMatch = App.ReadData("Match", "");
sReplace = App.ReadData("Replace", "");
aValues = new string[] {sMatch, sReplace};
aResults = Dialog.MultiInput(sTitle, aLabels, aValues);
if (aResults == null || aResults.Length == 0) return;

sMatch = Regex.Escape(aResults[0]);
App.WriteData("Match", sMatch);
sMatch = Util.Literalize(sMatch);
sReplace = aResults[1];
App.WriteData("Replace", sReplace);
sReplace = Util.Literalize(sReplace);

sText = rtb.GetRange(iStart, iEnd);
iCount = Util.RegExpCountEquiv(sText, sMatch);
sText = Util.RegExpReplaceEquiv(sText, sMatch, sReplace);
rtb.ReplaceRange(iStart, iEnd, sText);
AddMessage(Util.Pluralize(iCount, "match", "matches"));
}

if (menuItem == menuDeleteReplaceWithRegExp) {
if (rtb.SelectionLength == 0) {
sTitle = "Replace All with Regular Expression";
iStart = 0;
iEnd = rtb.TextLength;
}
else {
sTitle = "Replace Selected with Regular Expression";
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

aLabels = new string[] {"&Pattern", "&Substitute"};
sPattern = App.ReadData("Pattern", "");
sSubstitute = App.ReadData("Substitute", "");
aValues = new string[] {sPattern, sSubstitute};
aResults = Dialog.MultiInput(sTitle, aLabels, aValues);
if (aResults == null || aResults.Length == 0) return;

sPattern = aResults[0];
App.WriteData("Pattern", sPattern);
//sPattern = Util.Literalize(sPattern);
sSubstitute = aResults[1];
App.WriteData("Substitute", sSubstitute);
//sSubstitute = Util.Literalize(sSubstitute);
sText = rtb.GetRange(iStart, iEnd);
iCount = Util.RegExpCountCase(sText, sPattern);
sText = Util.RegExpReplaceCase(sText, sPattern, sSubstitute);
rtb.ReplaceRange(iStart, iEnd, sText);
AddMessage(Util.Pluralize(iCount, "match", "matches"));
}

if (menuItem == menuMiscYieldWithRegExp) {
if (rtb.SelectionLength == 0) {
sTitle = "Yield All with Regular Expression";
iStart = 0;
iEnd = rtb.TextLength;
}
else {
sTitle = "Yield Selected with Regular Expression";
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sLabel = "Pattern";
sValue = App.ReadData("Pattern", "");
sResult = Dialog.Input(sTitle, sLabel, sValue);
if (sResult.Length == 0) return;

App.WriteData("Pattern", sResult);
//sResult = Util.Literalize(sResult);
sText = rtb.GetRange(iStart, iEnd);
iCount = Util.RegExpCountCase(sText, sResult);
AddMessage(Util.Pluralize(iCount, "match", "matches"));
}

if (menuItem == menuMiscExtractWithRegExp) {
if (rtb.SelectionLength == 0) {
sTitle = "Extract All with Regular Expression";
iStart = 0;
iEnd = rtb.TextLength;
}
else {
sTitle = "Extract Selected with Regular Expression";
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sLabel = "Pattern";
sValue = App.ReadData("Pattern", "");
sResult = Dialog.Input(sTitle, sLabel, sValue);
if (sResult.Length == 0) return;

App.WriteData("Pattern", sResult);
//sResult = Util.Literalize(sResult);
sText = rtb.GetRange(iStart, iEnd);
aResults = Util.RegExpExtractCase(sText, sResult);
iCount = aResults.Length;
AddMessage(Util.Pluralize(iCount, "match", "matches"));
if (iCount == 0) return;

new MdiChild(this);
rtb = App.Frame.Child.RTB;
sText = String.Join(SectionBreak, aResults);
rtb.ReplaceRange(0, 0, sText);
rtb.Index = 0;
}

if (menuItem == menuMiscRunAtCursor) {
if (rtb.SelectionLength == 0) {
sTitle = "Run Chunk at Cursor";
object[] a = GetChunk();
sText = (string) a[1];
}
else {
sTitle = "Run Selected at Cursor";
sText = rtb.SelectedText;
}

sLabel = "Path";
sReplace = "";
sMatch = "(\r|\n)";
sText = Util.RegExpReplaceCase(sText, sMatch, sReplace);
sMatch = "^(\\<| )+";
sText = Util.RegExpReplaceCase(sText, sMatch, sReplace);
sMatch = "(\\>| |\\.)+$";
sText = Util.RegExpReplaceCase(sText, sMatch, sReplace);

if (sText.Contains("://")) sText = sText.Trim(); //do nothing
else if (sText.ToLower().StartsWith("www.")) sText = "http://" + sText;
else if (sText.Contains("@") && !sText.ToLower().StartsWith("mailto")) sText = "MailTo:" + sText;

sResult = Dialog.Input(sTitle, sLabel, sText).Trim();
if (sResult.Length == 0) return;
Process.Start(sResult);
}

if (menuItem == menuDeleteLine) {
iStart = rtb.RowStart;
iEnd = iStart + rtb.RowLength;
rtb.ReplaceRange(iStart, iEnd, "");
rtb.Index = iStart;
AddMessage(rtb.RowText);
}

if (menuItem == menuDeleteRight) {
iStart = rtb.Index;
iEnd = rtb.RowStart + rtb.RowText.Length;
if (iEnd != rtb.TextLength) iEnd--;
rtb.ReplaceRange(iStart, iEnd, "");
rtb.Index = iStart;
AddMessage(rtb.RowText);
}

if (menuItem == menuDeleteLeft) {
iStart = rtb.RowStart;
iEnd = rtb.Index;
rtb.ReplaceRange(iStart, iEnd, "");
rtb.Index = iStart;
AddMessage(rtb.RowText);
}

if (menuItem == menuDeleteDown) {
iStart = rtb.Index;
iEnd = rtb.TextLength;
rtb.ReplaceRange(iStart, iEnd, "");
rtb.Index = iStart;
AddMessage(rtb.RowText);
}

if (menuItem == menuDeleteUp) {
iStart = 0;
iEnd = rtb.Index;
rtb.ReplaceRange(iStart, iEnd, "");
rtb.Index = iStart;
AddMessage(rtb.RowText);
}

if (menuItem == menuDeleteFile) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

if (Dialog.Confirm("Confirm", "Delete " + child.Text + "?", "N") != "Y") return;
File.Delete(sFile);
child.Close();
}

if (menuItem == menuDeleteTrimBlanks) {
if (rtb.SelectionLength == 0) {
AddMessage("Line");
iStart = rtb.RowStart;
iEnd = iStart + rtb.RowLength;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
sText = Util.RegExpReplaceCase(sText, "^( |\t)+", "");
sText = Util.RegExpReplaceCase(sText, "( |\t)+$", "");
sText = Util.RegExpReplaceCase(sText, "\n\n\n\n+", "\n\n\n");
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
AddMessage(rtb.RowText);
}

if (menuItem == menuNavigateForwardFind || menuItem == menuNavigateForwardFindAgain) {
sText = App.ReadData("Find", "");
if (menuItem == menuNavigateForwardFind) sText = Dialog.Input("Forward Find", "Text", sText);
if (sText.Length == 0) return;

App.WriteData("Find", sText);
sText = Util.Literalize(sText);
sText = Util.Convert2MacLineBreak(sText);
if (rtb.SelectionLength == 0) {
iStart = rtb.Index;
iEnd = -1;
}
else {
iStart = rtb.SelectionStart;
iEnd = rtb.SelectionStart + rtb.SelectionLength;
}

iIndex = rtb.Find(sText, iStart, iEnd, RichTextBoxFinds.NoHighlight);
if (iIndex >= 0) {
rtb.Index = iIndex + sText.Length;
AddMessage(rtb.RowText);
}
else AddMessage("Not found!");
}

if (menuItem == menuNavigateReverseFind || menuItem == menuNavigateReverseFindAgain) {
sText = App.ReadData("Find", "");
if (menuItem == menuNavigateReverseFind) sText = Dialog.Input("Reverse Find", "Text", sText);
if (sText.Length == 0) return;

App.WriteData("Find", sText);
sText = Util.Literalize(sText);
sText = Util.Convert2MacLineBreak(sText);
if (rtb.SelectionLength == 0) {
iStart = 0;
iEnd = rtb.Index;
}
else {
iStart = rtb.SelectionStart;
iEnd = rtb.SelectionStart + rtb.SelectionLength;
}

iIndex = rtb.Find(sText, iStart, iEnd, RichTextBoxFinds.Reverse | RichTextBoxFinds.NoHighlight);
//if (iIndex >= 0) {
if (iIndex >= 0 && iIndex < iEnd) {
rtb.Index = iIndex;
AddMessage(rtb.RowText);
}
else AddMessage("Not found!");
}

if (menuItem == menuNavigateJumpToLine || menuItem == menuNavigateJumpToLineAgain) {
sText = App.ReadData("Jump", "");
if (menuItem == menuNavigateJumpToLine) sText = Dialog.Input("Jump to", "Line", sText);
if (sText.Length == 0) return;

string[] a = sText.Split(',');
sLine = a[0].Trim();
if (sLine.Length == 0) sLine = rtb.Line.ToString();
string sColumn = a.Length > 1 ? a[1].Trim() : "1";

try {
iLine = Int32.Parse(sLine);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}

int iColumn = 1;
try {
iColumn = Int32.Parse(sColumn);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}

App.WriteData("Jump", sText);
rtb.Line = iLine;
rtb.Column = iColumn;
AddMessage(rtb.RowText);
}

if (menuItem == menuNavigateSearchForTopic || menuItem == menuNavigateSearchForTopicAgain) {
sText = App.ReadData("Topic", "");
if (menuItem == menuNavigateSearchForTopic) {
sText = Dialog.Input("Search For", "Topic", sText);
iStart = 0;
}
else iStart = rtb.Index;
if (sText.Length == 0) return;

App.WriteData("Topic", sText);
sMatch = SB + ".*?" + sText + ".*?" + LB;
sText = rtb.Text;
iIndex = (int) Util.RegExpContainsEquiv(sText, sMatch, iStart)[0];
if (iIndex == -1) {
AddMessage("Not found!");
return;
}
rtb.Index = iIndex + SB.Length;
AddMessage(rtb.RowText);
}

if (menuItem == menuNavigateGoToPercent || menuItem == menuNavigateGoToPercentAgain) {
sText = App.ReadData("Percent", "");
if (menuItem == menuNavigateGoToPercent) sText = Dialog.Input("Go to", "Percent", sText);
if (sText.Length == 0) return;

try {
iPercent = Int32.Parse(sText);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}

App.WriteData("Percent", sText);
rtb.Percent = iPercent;
AddMessage(rtb.RowText);
}

if (menuItem == menuNavigateSetBookmark) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

sText = rtb.Index + "|" + (rtb.ReadOnly ? "G" : "M") + "|" + (string) Util.If(rtb.WordWrap, "W", "U");
App.WriteValue("Favorites", sFile, sText);
}

if (menuItem == menuNavigateClearBookmark) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

sText = App.ReadValue("Favorites", sFile, "-1");
if (sText.StartsWith("-1")) return;
string[] a = sText.Split('|');
a[0] = "-1";
sText = String.Join("|", a);
App.WriteValue("Favorites", sFile, sText);
}

if (menuItem == menuNavigateGoToBookmark) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

sText = "-1";
sText = App.ReadValue("Favorites", sFile, sText);
if (sText.StartsWith("-1")) {
AddMessage("No bookmark!");
return;
}

string[] a = sText.Split('|');
sText = a[0];
rtb.Index = Int32.Parse(sText);
AddMessage(rtb.RowText);
}

if (menuItem == menuFileSetFavorite) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

sText = "-1";
sText = App.ReadValue("Favorites", sFile, sText);
string[] a = sText.Split('|');
sText = a[0]  + "|" + (rtb.ReadOnly ? "G" : "M") + "|" + Util.If(rtb.WordWrap, "W", "U");
App.WriteValue("Favorites", sFile, sText);
}

if (menuItem == menuFileClearFavorite) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

App.DeleteKey("Favorites", sFile);
}

if (menuItem == menuFileListFavorites) {
aResults = App.ReadSectionKeys("Favorites");
List<string> list = new List<string>(aResults);
for (int i = list.Count - 1; i >=0; i--) {
string s = list[i];
if (File.Exists(s)) continue;
App.DeleteKey("Favorites", s);
list.RemoveAt(i);
}

aResults = list.ToArray();
if (aResults.Length == 0) {
AddMessage("No items!");
return;
}

string[] aDisplay = new string[aResults.Length];
for (int i = 0; i < aDisplay.Length; i++) aDisplay[i] = Path.GetFileName(aResults[i]);
sFile = Dialog.Pick("List Favorites", aResults, aDisplay, true, 0);
if (sFile.Length == 0) return;

OpenOrActivateWindow(sFile, 1);
}

if (menuItem == menuNavigateGoToStartOfSelection) {
rtb.Index = rtb.StartSelection;
AddMessage(rtb.RowText);
}

if (menuItem == menuNavigateHomeCharacter) {
sText = rtb.RowText;
iLength = sText.TrimStart().Length;
if (iLength == 0) return;
iIndex = rtb.RowStart + (sText.Length - iLength);
rtb.Index = iIndex;
sText = rtb.GetRange(iIndex, iIndex + 1);
AddMessage(sText);
}

if (menuItem == menuNavigateEndCharacter) {
sText = rtb.RowText;
iLength = sText.TrimEnd().Length;
if (iLength == 0) return;
iIndex = rtb.RowStart + iLength - 1;
rtb.Index = iIndex;
sText = rtb.GetRange(iIndex, iIndex + 1);
AddMessage(sText);
}

if (menuItem == menuNavigateRightBrace || menuItem == menuNavigateLeftBrace || menuItem == menuQueryBraces) {
sText = App.ReadOption("BraceMatch", "{}");
string sLeft = sText.Substring(0, 1);
string sRight = sText.Substring(1, 1);
iIndex = rtb.Index;
string s = rtb.GetRange(iIndex, iIndex + 1);
switch (s) {
case "{" :
case "}" :
sLeft = "{";
sRight = "}";
break;
case "<" :
case ">" :
sLeft = "<";
sRight = ">" ;
break;
case "[" :
case "]" :
sLeft = "[";
sRight = "]";
break;
case "(" :
case ")" :
sLeft = "(";
sRight = ")";
break;
}

if (menuItem == menuNavigateRightBrace) {
iStart = iIndex;
iEnd = rtb.TextLength;
sText = rtb.GetRange(iStart, iEnd);
iCount = 0;
int i = 0;
bool bLoop = true;
while (bLoop) {
if (i == sText.Length) {
bLoop = false;
AddMessage("Not found!");
}
else if (sText.Substring(i, 1) == sLeft && i > 0) {
iCount++;
i++;
}
else if (sText.Substring(i, 1) == sRight && iCount > 0) {
iCount --;
i++;
}
else if (sText.Substring(i, 1) == sRight && iCount == 0 && i > 0) {
bLoop = false;
iIndex = iStart + i;
rtb.Index = iIndex;
}
else i++;
}
AddMessage(rtb.RowText);
}
else if (menuItem == menuNavigateLeftBrace) {
iStart = 0;
iEnd = iIndex;
sText = rtb.GetRange(iStart, iEnd);
sText = Util.Reverse(sText);
iCount = 0;
int i = 0;
bool bLoop = true;
while (bLoop) {
if (i == sText.Length) {
bLoop = false;
AddMessage("Not found!");
}
else if (sText.Substring(i, 1) == sRight) {
iCount++;
i++;
}
else if (sText.Substring(i, 1) == sLeft && iCount > 0) {
iCount --;
i++;
}
else if (sText.Substring(i, 1) == sLeft && iCount == 0) {
bLoop = false;
iIndex = iEnd - i - 1;
rtb.Index = iIndex;
}
else i++;
}
AddMessage(rtb.RowText);
}
else if (menuItem == menuQueryBraces) {
iStart = iIndex;
iEnd = rtb.TextLength;
sText = rtb.GetRange(iStart, iEnd);
iCount = 0;
int i = 0;
bool bLoop = true;
while (bLoop) {
if (i == sText.Length) {
bLoop = false;
}
else if (sText.Substring(i, 1) == sLeft && i > 0) {
iCount++;
i++;
}
else if (sText.Substring(i, 1) == sRight) {
iCount--;
i++;
}
else i++;
}
int iOutLevels = iCount;
iStart = 0;
iEnd = iIndex;
sText = rtb.GetRange(iStart, iEnd);
sText = Util.Reverse(sText);
iCount = 0;
i = 0;
bLoop = true;
while (bLoop) {
if (i == sText.Length) {
bLoop = false;
}
else if (sText.Substring(i, 1) == sRight) {
iCount++;
i++;
}
else if (sText.Substring(i, 1) == sLeft) {
iCount--;
i++;
}
else i++;
}
int iInLevels = iCount;
AddMessage(Util.Absolute(iInLevels) + " left");
AddMessage(Util.Absolute(iOutLevels) + " right");
}
}

if (menuItem == menuNavigateNextBlock) {
string sComment = App.ReadOption("QuotePrefix", "> ");
//sComment = Util.Literalize(sComment);
int iLevels = GetIndent();
int i = iLevels;
int iRow = rtb.Row;
int iBottom = rtb.BottomRow;
//rtb.BeginUpdate();
while (iRow < iBottom) {
iRow++;
rtb.Row = iRow;
sLine = rtb.RowText.Trim();
if (sLine.Length == 0 || sLine.StartsWith(sComment)) continue;
i = GetIndent();
if (iLevels != i) break;
}
//rtb.EndUpdate();

if (iLevels == i) {
AddMessage("Bottom!");
rtb.Index = rtb.TextLength;
}
else AddMessage(GetDelta(iLevels, i));
//AddMessage(rtb.RowText);
Util.Say(rtb.RowText);
}

if (menuItem == menuNavigatePriorBlock) {
string sComment = App.ReadOption("QuotePrefix", "> ");
//sComment = Util.Literalize(sComment);
int iLevels = GetIndent();
int i = iLevels;
int iRow = rtb.Row;
int iTop = 0;
//rtb.BeginUpdate();
while (iRow > iTop) {
iRow--;
rtb.Row = iRow;
sLine = rtb.RowText.Trim();
if (sLine.Length == 0 || sLine.StartsWith(sComment)) continue;
i = GetIndent();
if (iLevels != i) break;
}
//rtb.EndUpdate();

if (iLevels == i) {
AddMessage("Top!");
rtb.Index = 0;
}
else AddMessage(GetDelta(iLevels, i));
//AddMessage(rtb.RowText);
Util.Say(rtb.RowText);
}

if (menuItem == menuNavigateNextChunk) {
sMatch = "\\s+";
NavigateNextMatch(sMatch);
}

if (menuItem == menuNavigatePriorChunk) {
sMatch = "\\s+";
NavigatePriorMatch(sMatch);
}

if (menuItem == menuNavigateNextSentence) {
sMatch = "((\\.|\\?|\\!)\\s+)|(\\n\\s*\\n(\\n|\\n)*)";
NavigateNextMatch(sMatch);
}

if (menuItem == menuNavigatePriorSentence) {
sMatch = "((\\.|\\?|\\!)\\s+)|(\\n\\s*\\n(\\n|\\n)*)";
NavigatePriorMatch(sMatch);
}

if (menuItem == menuNavigateNextParagraph) {
sMatch = "\\n\\s*\\n(\\n|\\n)*";
NavigateNextMatch(sMatch);
}

if (menuItem == menuNavigatePriorParagraph) {
sMatch = "((\\.|\\?|\\!)\\s+)|(\\n\\s*\\n(\\n|\\n)*)";
NavigatePriorMatch(sMatch);
}

if (menuItem == menuNavigateNextPart) {
sMatch = @"^\s*((Chapter)|(Section)|(Part))\s+\d";
sMatch = App.ReadOption("NavigatePart", sMatch);
NavigateNextMatch(sMatch, true);
}

if (menuItem == menuNavigatePriorPart) {
sMatch = @"^\s*((Chapter)|(Section)|(Part))\s+\d";
sMatch = App.ReadOption("NavigatePart", sMatch);
NavigatePriorMatch(sMatch, true);
}

if (menuItem == menuNavigateNextSection) {
iStart = rtb.Index;
sText = rtb.Text;
iEnd = rtb.TextLength;
iIndex = sText.IndexOf(SB, iStart);
if (iIndex == -1) {
AddMessage("Bottom!");
rtb.Index = iEnd;
sLine = rtb.Lines[rtb.Lines.Length - 1];
return;
}
else {
rtb.Index = iIndex + 2;
sText = sText.Substring(0, iIndex);
string[] aText = sText.Split('\n');
iLine = aText.Length;
sLine = rtb.Lines[iLine];
}
AddMessage(rtb.RowText);
}

if (menuItem == menuNavigatePriorSection) {
iEnd = rtb.Index;
if (iEnd > 0) iEnd--;
sText = rtb.Text.Substring(0, iEnd);
iIndex = sText.LastIndexOf(SB);
if (iIndex == -1) {
AddMessage("Top!");
rtb.Index = 0;
}
else {
rtb.Index = iIndex + 2;
AddMessage(rtb.RowText);
}
}

if (menuItem == menuNavigateGoToSection) {
sLine = SB + rtb.RowText;
sText = rtb.Text;
iIndex = sText.IndexOf(sLine);
if (iIndex == -1) {
AddMessage("Not found!");
}
else {
rtb.Index = iIndex + SB.Length;
AddMessage(rtb.RowText);
}
}

if (menuItem == menuNavigateGoToContents) {
sText = rtb.Text;
iIndex = sText.IndexOf(LB, rtb.Index);
if (iIndex == -1) {
AddMessage("Not found!");
return;
}
iEnd = iIndex + LB.Length;
sText = sText.Substring(0, iEnd);
iIndex = sText.LastIndexOf(SB);
if (iIndex == -1) {
AddMessage("Not found!");
return;
}
iStart = iIndex + SB.Length;
iIndex = sText.IndexOf(LB, iStart);
if (iIndex == -1) {
AddMessage("Not found!");
return;
}
iEnd = iIndex + LB.Length;
sLine = LB + sText.Substring(iStart, iEnd - iStart);
iIndex = sText.IndexOf(sLine);
if (iIndex == -1) {
AddMessage("Not found!");
return;
}
rtb.Index = iIndex + LB.Length;
AddMessage(rtb.RowText);
}

if (menuItem == menuNavigateSearchForTopic) {
}

if (menuItem == menuQueryAddress) {
SetStatusAddress(null, null);
}

if (menuItem == menuQueryIndent) {
AddMessage(Util.Pluralize(this.GetIndent(), "level"));
}

if (menuItem == menuQueryPath) {
AddMessage(child.File);
}

if (menuItem == menuQueryTopic) {
sText = rtb.Text;
iIndex = sText.IndexOf(LB, rtb.Index);
if (iIndex == -1) {
AddMessage("Not found!");
return;
}
iEnd = iIndex + LB.Length;
sText = sText.Substring(0, iEnd);
iIndex = sText.LastIndexOf(SB);
if (iIndex == -1) {
AddMessage("Not found!");
return;
}
iStart = iIndex + SB.Length;
iIndex = sText.IndexOf(LB, iStart);
if (iIndex == -1) {
AddMessage("Not found!");
return;
}
iEnd = iIndex + LB.Length;
sLine = sText.Substring(iStart, iEnd - iStart);
AddMessage(sLine);
}

if (menuItem == menuQueryYield) {
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
if (iStart == iEnd) {
AddMessage("All");
iStart = 0;
iEnd = rtb.TextLength;
}
else  AddMessage("Selected");

sText = rtb.GetRange(iStart, iEnd);
iResult = sText.Length;
AddMessage(Util.Pluralize(iResult, "character"));

if (iResult > 0) {
iResult = Util.RegExpCountCase(sText, "\\S+");
AddMessage(Util.Pluralize(iResult, "Word"));
iResult = Util.RegExpCountCase(sText, LB) + 1;
AddMessage("\t" + Util.Pluralize(iResult, "Line"));
}

}

if (menuItem == menuQueryStatus) {
sText = rtb.Modified ? "Modified" : "Unmodified" + "\t";
sText += rtb.WordWrap ? "Wrap" : "Unwrap";
sText += rtb.ReadOnly ? "Guard" : "";
AddMessage(sText);
}

if (menuItem == menuQuerySelected) {
sText = rtb.SelectedText;
if (sText.Length == 0) sText = "No text!";
AddMessage(sText);
}

if (menuItem == menuQueryChunk) {
object[] a = GetChunk();
sText = (string) a[1];
if (sText.Length == 0) sText = "No text!";
AddMessage(sText);
}

if (menuItem == menuQueryReadAll) {
sText = rtb.Text;
if (sText.Length == 0) sText = "No text!";
AddMessage(sText);
}

if (menuItem == menuQueryWindowsOpen) {
WindowsOpen();
}

if (menuItem == menuQueryClipboard) {
sText = Clipboard.GetText();
if (sText.Length == 0) sText = "No text!";
AddMessage(sText);
}

if (menuItem == menuQueryTime || menuItem == menuMiscInsertTime) {
DateTime dt = DateTime.Now;
sText = dt.ToShortTimeString() + " on " + dt.ToLongDateString();
if (menuItem == menuQueryTime) AddMessage(sText);
else {
rtb.ReplaceRange(rtb.Index, rtb.Index, sText);
AddMessage(rtb.RowText);
}
}

if (menuItem == menuMiscCalculateDate) {
CalculateDate();
}

if (menuItem == menuMiscHTMLFormat) {
sText = rtb.Text.Trim();
aResults = sText.Split('\n');
sTitle = aResults[0];
List<string> list = new List<string>(aResults);
list.RemoveAt(0);
aResults = list.ToArray();
sText = String.Join("\n", aResults);
sText = Util.String2Html(sText);
//sMatch = @"\nContents\s*\n(.|\n)*?\f\n";
sMatch = @"\n\s*?Contents\s*?\n[^\f]*";
string sOldContents = "";
string sContents = "";
string sPreContents = "";
string sPostContents = "";
object[] a = Util.RegExpContainsEquiv(sText, sMatch);
iIndex = (int) a[0];
if (iIndex >= 0) {
sOldContents = (string) a[1];
sPreContents = sText.Substring(0, iIndex - 1);
sPostContents = sText.Substring(iIndex + sOldContents.Length);
sPostContents = Util.RegExpReplaceCase(sPostContents, "\n----------\n", "\n");
sContents = sOldContents.Trim();
aResults = sContents.Split('\n');
StringBuilder sb = new StringBuilder();
int j = 0;
for (int i = 0; i < aResults.Length; i++) {
string s = aResults[i];
if (i == 0) {
s = "<h1>" + s + "</h1>\n<ul>";
}
else if (s.Trim().Length == 0 || s.StartsWith("----------")) {
continue;
//s = s.Trim();
}
else {
j++;
string sHeader = "\n<h1><a name=\"A" + j + "\">" + s + "</a1></h1>\n";
sPostContents = Util.RegExpReplaceCase(sPostContents, "\f\n" + s + "\n", sHeader);
s = "<li><a href=\"#A" + j + "\">" + s + "</a></li>";
}
sb.Append(s + "\n");
}
sb.Append ("</ul>\n");
sContents = sb.ToString();
sContents = "\n" + sContents;
}
else sPreContents = sText;

sPreContents = Util.RegExpReplaceCase(sPreContents, @"^(\w*\:\/\/.*?)$", "<a href=\"$1\">$1</a>");
sPreContents = Util.RegExpReplaceCase(sPreContents, @"^(\w*\@\w*\.\w*)$", "<a href=\"mailto:$1\">$1</a>");
sPreContents = Util.RegExpReplaceCase(sPreContents, " +\n", "\n");
sPreContents = Util.RegExpReplaceCase(sPreContents, "([^\n])\n([^\n])", "$1<br>\n$2");
sPreContents = Util.RegExpReplaceCase(sPreContents, "\n\n+", "\n<p>\n");

sPostContents = Util.RegExpReplaceCase(sPostContents, @"^(\w*\:\/\/.*?)$", "<a href=\"$1\">$1</a>");
sPostContents = Util.RegExpReplaceCase(sPostContents, @"^(\w*\@\w*\.\w*)$", "<a href=\"mailto:$1\">$1</a>");
sPostContents = Util.RegExpReplaceCase(sPostContents, " +\n", "\n");
sPostContents = Util.RegExpReplaceCase(sPostContents, "([^\n])\n([^\n])", "$1<br>\n$2");
sPostContents = Util.RegExpReplaceCase(sPostContents, "\n\n+", "\n<p>\n");

sText = sPreContents + sContents + sPostContents;
sText = sText.Trim();
sText = "<html>\n<head>\n<title>" + sTitle + "</title>\n</head>\n<body>\n" + sText + "\n</body>\n</html>\n";
sFile = Path.GetFileNameWithoutExtension(child.File) + ".htm";
new MdiChild(this);
this.Child.File = sFile;
this.Child.Text = sFile;
this.Child.RTB.Text = sText;
this.Child.RTB.Modified = false;
}

if (menuItem == menuMiscTextConvert || menuItem == menuMiscTextCombine) {
List<string> list = new List<string>();
aResults = rtb.Lines;
for (int i = 0; i < aResults.Length; i++) {
string s = aResults[i].Trim();
if (File.Exists(s)) list.Add(s);
}

aResults = list.ToArray();
if (aResults.Length == 0) {
AddMessage("No files found!");
return;
}

sText = Util.GetExtensions(aResults);
sResult = Dialog.Input("Filter", "Extensions", sText).Trim();
if (sResult.Length == 0) return;

aResults = Util.GetFilesWithExtensions(aResults, sResult);
if (aResults.Length == 0) {
AddMessage("No files!");
return;
}

StringBuilder sb = new StringBuilder();
iCount = 0;
AddMessage("Converting");
for (int i = 0; i < aResults.Length; i++) {
string sSource = aResults[i];
string sTarget = Path.ChangeExtension(sSource, ".txt");
AddMessage(Path.GetFileName(sSource));
//sText = COM.WordFile2String(sSource);
sText = COM.ConvertFile2String(sSource);
if (sText.Length == 0) {
AddMessage("Error!");
continue;
}

iCount++;
if (menuItem == menuMiscTextConvert) Util.String2File(sText, sTarget);
else if (iCount == 1) sb.Append(sText);
else sb.Append(SectionBreak + sText);
}

AddMessage("Converted " + Util.Pluralize(iCount, "file"));
if (menuItem == menuMiscTextConvert || iCount == 0) return;

if (!IsEmptyWindow()) new MdiChild(this);
sText = sb.ToString();
sText += EOD;
rtb = this.Child.RTB;
rtb.Text = sText;
rtb.Modified = false;
}

if (menuItem == menuMiscTextContents) {
//sMatch = "(^|(" + SB + "))" + "[^\n]*";
sMatch = "(\\A|(" + SB + "))" + "[^\n]*";
aResults = Util.RegExpExtractCase(rtb.Text, sMatch);
iCount = aResults.Length;
AddMessage(Util.Pluralize(iCount, "topic"));
if (iCount == 0) return;

sText = String.Join(LB, aResults);
sText = sText.Replace(SB, "");
sText = "Contents" + LB + sText + SectionBreak;
rtb.ReplaceRange(0, 0, sText);
rtb.Index = 0;
}

if (menuItem == menuMiscSetFontAndColor) {
object[] a = Dialog.GetFontAndColor(rtb.Font, rtb.ForeColor);
if (a.Length == 0) return;

rtb.Font = (Font) a[0];
rtb.ForeColor = (Color) a[1];
string sFont = Util.Font2String(rtb.Font);
string sColor = Util.Color2String(rtb.ForeColor);
sFont += ", Color=" + sColor;
App.WriteOption("Font", sFont);
}


if (menuItem == menuMiscConfigurationOptions) {
aResults = App.ReadDefaultOptions();
Array.Sort(aResults);
aLabels = new string[aResults.Length];
string[] aDefaults = new string[aResults.Length];
aValues = new string[aResults.Length];
for (int i = 0; i < aResults.Length; i++) {
aLabels[i] = "&" + aResults[i];
aDefaults[i] = App.ReadDefaultOption(aResults[i], "");
aValues[i] = App.ReadOption(aResults[i], aDefaults[i]);
}

string[] a = Dialog.MultiInput("Configuration Options", aLabels, aValues);
if (a.Length == 0) return;
for (int i = 0; i < a.Length; i++) App.WriteOption(aResults[i], a[i]);
}

if (menuItem == menuMiscManualOptions) {
OpenOrActivateWindow(App.IniFile, 0);
}

if (menuItem == menuMiscWordWrap) {
rtb.SetWrap(true);
SetRecent(child.File);
}

if (menuItem == menuMiscUnwrap) {
rtb.SetWrap(false);
SetRecent(child.File);
}

if (menuItem == menuMiscPathToClipboard) {
sText = child.File;
Clipboard.SetText(sText);
AddMessage(sText);
}

if (menuItem == menuMiscPathList) {
sTitle = "Open Folder";
string sDir = Dialog.OpenFolder(sTitle, "Name", Directory.GetCurrentDirectory());
if (sDir.Length == 0) return;

Directory.SetCurrentDirectory(sDir);

sText = Util.GetExtensions(sDir);
if (sText.Length == 0) {
AddMessage("No files!");
return;
}

sResult = Dialog.Input("Filter", "Extensions", sText);
if (sDir.Length == 0) return;

aResults = Util.GetFilesWithExtensions(Directory.GetFiles(sDir), sResult);
iLength = aResults.Length;
sText = Util.Pluralize(iLength, "file");
AddMessage(sText);

if (!IsEmptyWindow()) new MdiChild(this);
child = this.Child;
rtb = child.RTB;
for (int i = 0; i < iLength; i++) {
if (i == 0) sText = aResults[i] + "\n";
else sText += Path.GetFileName(aResults[i]) + "\n";
}
rtb.Text = sText;
rtb.Modified = true;
}

if (menuItem == menuMiscExplorerFolder) {
ExplorerFolder();
}

if (menuItem == menuMiscEvaluateExpression) {
if (rtb.SelectionLength == 0) {
AddMessage("Line");
sText = rtb.RowText;
iIndex = rtb.RowStart + sText.Length;
}
else {
AddMessage("Selected");
sText = rtb.SelectedText;
iIndex = rtb.SelectionStart + sText.Length;
}

sText = JS.Eval(sText, new object[] {}).ToString();
if (sText.Length == 0) return;

sText = LB + sText;
rtb.ReplaceRange(iIndex, iIndex, sText);
rtb.Index = iIndex + 1;
AddMessage(rtb.RowText);
}

if (menuItem == menuMiscPickCompiler) {
aResults = Ini.ReadSectionKeys(App.IniFile, "Compilers");
sResult = Dialog.Pick("Pick Compiler", aResults, true, 0);
if (sResult.Length == 0) return;

sValue = Ini.ReadValue(App.IniFile, "Compilers", sResult, "");
string[] a = sValue.Split('~');
Ini.WriteQuote(App.IniFile, "Options", "CompileCommand", a[0]);
if (a.Length > 1) Ini.WriteQuote(App.IniFile, "Options", "JumpPosition", a[1]);
if (a.Length > 2) Ini.WriteQuote(App.IniFile, "Options", "AbbreviateOutput", a[2]);
if (a.Length > 3) Ini.WriteQuote(App.IniFile, "Options", "NavigatePart", a[3]);
if (a.Length > 4) Ini.WriteQuote(App.IniFile, "Options", "QuotePrefix", a[4]);
}

if (menuItem == menuMiscCompile) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

child.SaveTextFile(sFile);
string sCommand = App.ReadOption("CompileCommand", "");
string sDir = Directory.GetCurrentDirectory();
if (sCommand.IndexOf("%SourceDir%") >=0) Directory.SetCurrentDirectory(Path.GetDirectoryName(sFile));
sCommand = Util.ExpandCommandLine(sCommand, sFile, Path.ChangeExtension(sFile, ".exe"));
string sOutput = Util.GetProgramOutput("cmd.exe", "/c " + sCommand);
//Dialog.Show(sCommand);
int i = sCommand.IndexOf(".exe");
string sParams = sCommand.Substring(i + 5);
sCommand = sCommand.Substring(0, i + 4);
//Dialog.Show(sCommand, sParams);
//string sOutput = Util.GetProgramOutput(sCommand, sParams);
//Dialog.Show(sOutput);
string sJumpPosition = App.ReadOption("JumpPosition", "");
object[] a = Util.RegExpContainsCase(sOutput, sJumpPosition);
iIndex = (int) a[0];
if (iIndex >= 0) {
sText = (string) a[1];
a = Util.RegExpContainsCase(sText, @"\d+");
iIndex = (int) a[0];
if (iIndex >= 0) {
sLine = (string) a[1];
iIndex += sLine.Length;
sText = sText.Substring(iIndex);
a = Util.RegExpContainsCase(sText, @"\d+");
iIndex = (int) a[0];
string sColumn;
if (iIndex == -1) sColumn = "1";
else sColumn = (string) a[1];
rtb.Line = Int32.Parse(sLine);
rtb.Column = Int32.Parse(sColumn);
}
}

string sAbbreviateOutput = App.ReadOption("AbbreviateOutput", "\r");
sOutput = Util.RegExpReplaceEquiv(sOutput, sAbbreviateOutput, "\n").Trim();
if (sOutput.Length == 0) sOutput = "Done!";
if (sDir != Directory.GetCurrentDirectory()) Directory.SetCurrentDirectory(sDir);
AddMessage(sOutput);
}

if (menuItem == menuMiscKeepUniqueLines) {
if (rtb.SelectionLength == 0) {
AddMessage("All");
iStart = 0;
iEnd = rtb.TextLength;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
aResults = sText.Split('\n');
List<string> listNormal = new List<string>();
List<string> listLower = new List<string>();
foreach (string s in aResults) {
string sLower = s.ToLower();
if (listLower.Contains(sLower)) continue;
listLower.Add(sLower);
listNormal.Add(s);
}

aResults = listNormal.ToArray();
sText = String.Join("\n", aResults);
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
}

if (menuItem == menuMiscNumberLines) {
if (rtb.SelectionLength == 0) {
sTitle = "Number Lines All";
iStart = 0;
iEnd = rtb.TextLength;
}
else {
sTitle = "Number Lines Selected";
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sResult = Dialog.Input(sTitle, "Start", "1").Trim();
if (sResult.Length == 0) return;

try {
iLine = Int32.Parse(sResult);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}

sText = rtb.GetRange(iStart, iEnd);
aResults = sText.Split('\n'); 
for (int i = 0; i < aResults.Length; i++) {
string s = aResults[i];
if (s.Trim().Length > 0) s = iLine++ + ". " + s;
aResults[i] = s;
}

sText = String.Join("\n", aResults);
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
}

if (menuItem == menuMiscOrderLines) {
if (rtb.SelectionLength == 0) {
AddMessage("All");
iStart = 0;
iEnd = rtb.TextLength;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
aResults = sText.Split('\n');
string[] a = new string[aResults.Length];
for (int i = 0; i < a.Length; i++) a[i] = aResults[i].ToLower();
Array.Sort(a, aResults);
sText = String.Join("\n", aResults);
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
}

if (menuItem == menuMiscReverseLines) {
if (rtb.SelectionLength == 0) {
AddMessage("All");
iStart = 0;
iEnd = rtb.TextLength;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

sText = rtb.GetRange(iStart, iEnd);
aResults = sText.Split('\n');
Array.Reverse(aResults);
sText = String.Join("\n", aResults);
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
}

if (menuItem == menuMiscListDifferentLines) {
aResults = rtb.GetRange(0, rtb.RowStart).Split('\n');
string[] a = rtb.GetRange(rtb.RowStart, rtb.TextLength).Split('\n');
List<string> list = new List<string>();
foreach (string s in aResults) if (s.Trim().Length > 0 && Array.IndexOf(a, s) == -1) list.Add(s);
aResults = list.ToArray();
if (aResults.Length == 0) {
AddMessage("No output!");
return;
}

AddMessage(Util.Pluralize(aResults.Length, "line"));
sText = String.Join("\n", aResults).TrimEnd('\n') + "\n";
child = new MdiChild(App.Frame);
Child.RTB.Text = sText;
rtb.Index = 0;
}

if (menuItem == menuMiscQueryCommonLines) {
aResults = rtb.GetRange(0, rtb.RowStart).Split('\n');
string[] a = rtb.GetRange(rtb.RowStart, rtb.TextLength).Split('\n');
List<string> list = new List<string>();
foreach (string s in aResults) if (s.Trim().Length > 0 && Array.IndexOf(a, s) >= 0) list.Add(s);
aResults = list.ToArray();
if (aResults.Length == 0) {
AddMessage("No output!");
return;
}

AddMessage(Util.Pluralize(aResults.Length, "line"));
sText = String.Join("\n", aResults).TrimEnd('\n') + "\n";
child = new MdiChild(App.Frame);
Child.RTB.Text = sText;
rtb.Index = 0;
}

if (menuItem == menuMiscCommandPrompt) {
CommandPrompt();
}

if (menuItem == menuWindowNext) {
NextWindow();
}

if (menuItem == menuWindowPrior) {
PriorWindow();
}

if (menuItem == menuHelpAbout) {
sText = "EdSharp 1.2\nAugust 22, 2007\n";
sText += "Copyright 2007 by Jamal Mazrui\nModified GPL License";
Dialog.Show("About", sText);
}

if (menuItem == menuHelpDocumentation) {
sFile = Path.Combine(App.ProgramDir, App.ProgramName) + ".htm";
Process.Start(sFile);
}
if (menuItem == menuHelpHistoryOfChanges) {
sFile = Path.Combine(App.ProgramDir, "History.txt");
OpenOrActivateWindow(sFile, 1);
}

if (menuItem == menuHelpHotKeySummary) {
sFile = Path.Combine(App.ProgramDir, "HotKeys.txt");
OpenOrActivateWindow(sFile, 1);
}

if (menuItem == menuHelpAlternateMenu) {
AlternateMenu();
}

if (menuItem == menuHelpContextMenu) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

ContextMenu(sFile);
}

if (menuItem == menuHelpSendToMenu) {
sFile = child.File;
if (!sFile.Contains(@"\")) {
AddMessage("No corresponding file on disk!");
return;
}

SendToMenu(sFile);
}

if (menuItem == menuHelpElevateVersion) {
ElevateVersion();
}

} // menuItem_Click handler

object[] GetChunk() {
bool bLoop;
int iIndex, iStart, iEnd;
string c, sText;
HomerRichTextBox rtb = this.Child.RTB;
sText = rtb.Text;
iIndex = rtb.Index;
c = "";
bLoop = true;

bLoop = true;
while (bLoop) {
if (iIndex == sText.Length) c = "";
else c = sText.Substring(iIndex, 1);
bLoop = (c.Trim().Length == 0);
bLoop = (bLoop && iIndex > 0);
if (bLoop) iIndex--;
}

bLoop = iIndex < sText.Length;
while (bLoop) {
c = sText.Substring(iIndex, 1);
bLoop = (c.Trim().Length > 0);
bLoop = (bLoop && iIndex > 0);
if (bLoop) iIndex--;
}
if (c.Trim().Length == 0) iIndex++;
iStart = iIndex;

bLoop = iIndex < sText.Length;
while (bLoop) {
c = sText.Substring(iIndex, 1);
bLoop = (c.Trim().Length > 0);
iIndex++;
bLoop = (bLoop && iIndex < sText.Length);
}
iEnd = iIndex;

if (iStart == iEnd) sText = "";
else sText = rtb.GetRange(iStart, iEnd);
return new object[] {iStart, sText};
} // GetChunk method

public void HardLineBreak() {
bool bLoop;
string sResult, sTitle, sBody, sText, sLine;
int iWidth, iLength, iIndex, iStart, iEnd, i;
HomerRichTextBox rtb = this.Child.RTB;
if (rtb.SelectionLength == 0) {
sTitle = "Hard Line Break All";
iStart = 0;
iEnd = rtb.TextLength;
}
else {
sTitle = "Hard Line Break Selected";
iStart = rtb.SelectionStart;
iEnd = iStart + rtb.SelectionLength;
}

iWidth = 0;
foreach (string s in rtb.Lines) {
iLength = s.Length;
if (iLength > iWidth) iWidth = iLength;
}

sText = iWidth.ToString();
sResult = Dialog.Input(sTitle, "Width", sText).Trim();
if (sResult.Length == 0) return;

try {
iWidth = Int32.Parse(sResult);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}

sText = rtb.GetRange(iStart, iEnd);
sBody = "";
iIndex = 0;
iLength = sText.Length;
bLoop = true;

while (bLoop) {
//Dialog.Show("index", iIndex);
if (iLength - iIndex <= iWidth) {
sLine = sText.Substring(iIndex);
bLoop = false;
}
else {
sLine = sText.Substring(iIndex, iWidth);
i = sLine.LastIndexOf("\n");
//Dialog.Show("break", i);
if (i >=0) {
sLine = sLine.Substring(0, i + 1);
}
else {
i = sLine.LastIndexOf(" ");
//Dialog.Show("space", i);
if (i >=0) sLine = sLine.Substring(0, i + 1);
}
}
sBody += sLine.TrimEnd('\n') + "\n";
iIndex += sLine.Length;
}

rtb.ReplaceRange(iStart, iEnd, sBody);
rtb.Index = iStart + sText.Length;
AddMessage(rtb.RowText);
} // HardLineBreak method

public void CalculateDate() {
DateTime dt = new DateTime();
int iIndex, iResult, iYear, iMonth, iWeek, iDay;
string sText, sTitle, sYear, sMonth, sWeek, sDay;
string[] aResults, aLabels, aValues;
HomerRichTextBox rtb = this.Child.RTB;

sYear = App.ReadData("Year", "");
sMonth = App.ReadData("Month", "");
sWeek = App.ReadData("Week", "");
sDay = App.ReadData("Day", "");
aLabels = new string[] {"&Year", "&Month", "&Week", "&Day"};
aValues = new string[] {sYear, sMonth, sWeek, sDay};
sTitle = "Calculate Date";
aResults = Dialog.MultiInput(sTitle, aLabels, aValues);
if (aResults.Length == 0) return;

sYear = aResults[0].Trim();
sMonth = aResults[1].Trim();
sWeek = aResults[2].Trim();
sDay = aResults[3].Trim();
App.WriteData("Year", sYear);
App.WriteData("Month", sMonth);
App.WriteData("Week", sWeek);
App.WriteData("Day", sDay);

iResult = Util.Month2Num(sMonth);
if (iResult != -1) sMonth = iResult.ToString();
iResult = Util.Day2Num(sDay);
if (iResult != -1) sDay = iResult.ToString();

try {
iYear = (sYear.Length == 0) ? 0 : Int32.Parse(sYear);
iMonth = (sMonth.Length == 0) ? 0 : Int32.Parse(sMonth);
iWeek = (sWeek.Length == 0) ? 0 : Int32.Parse(sWeek);
iDay = (sDay.Length == 0) ? 0 : Int32.Parse(sDay);
if (iWeek == 0) {
dt = new DateTime(iYear, iMonth, iDay);
}
else {
dt = new DateTime(iYear, iMonth, 1);
dt = dt.AddDays(7 * (iWeek - 1));
while ((int) dt.DayOfWeek != iDay) dt = dt.AddDays(1);
}
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
}

iIndex = rtb.Index;
sText = dt.ToLongDateString();
rtb.ReplaceRange(iIndex, iIndex, sText);
iIndex += sText.Length;
rtb.Index = iIndex;
AddMessage(rtb.RowText);
} // CalculateDate method

public void Mail(bool bAttach) {
bool bCreate, bVisible, bSendMailAttach;
int iDisplayAlerts;
string sText, sFile, sDir;
object oApp, oOptions, oDocs, oDoc;

HomerRichTextBox rtb = this.Child.RTB;
sText = rtb.Text;

if (sText.Length == 0) {
AddMessage("No text!");
return;
}
sText = Util.Convert2WinLineBreak(sText);
sFile = this.Child.Text;
sDir = Path.GetTempPath();
sFile = Path.Combine(sDir, sFile);
if (Path.GetExtension(sFile).Length == 0) sFile += ".txt";
//Util.String2File(sText, sFile);
Util.String2File(sText, App.TempFile);
App.TempFiles.Add(sFile);

bool bAppVisible = false;
//oApp = COM.GetOrCreateObject("Word.Application", out bCreate);
oApp = COM.WordAccess(out bCreate);
bVisible = (bool) COM.GetProperty(oApp, "Visible");
iDisplayAlerts = (int) COM.GetProperty(oApp, "DisplayAlerts");
COM.SetProperty(oApp, "Visible", bAppVisible);
COM.SetProperty(oApp, "DisplayAlerts", 0);
oOptions = COM.GetProperty(oApp, "Options");
bSendMailAttach = (bool) COM.GetProperty(oOptions, "SendMailAttach");
COM.SetProperty(oOptions, "SendMailAttach", bAttach);
oDocs = COM.GetProperty(oApp, "Documents");
oDoc = VB.WordOpen(oDocs, App.TempFile, bAppVisible);
if (File.Exists(sFile)) File.Delete(sFile);
VB.WordSaveAs(oDoc, sFile, 2);
COM.CallMethod(oDoc, "SendMail");
VB.WordClose(oDoc);
COM.Release(ref oDoc);
COM.Release(ref oDocs);
if (bCreate) {
//VB.WordQuit(oApp);
}
else {
COM.SetProperty(oApp, "Visible", bVisible);
COM.SetProperty(oApp, "DisplayAlerts", iDisplayAlerts);
COM.SetProperty(oOptions, "SendMailAttach", bSendMailAttach);
}
COM.Release(ref oOptions);
COM.Release(ref oApp);
File.Delete(sFile);

App.Frame.Activate();
App.Frame.Child.RTB.Select();
} // MailBody method

public void SpellCheck() {
bool bCreate, bVisible;
int iDisplayAlerts, iStart, iEnd, iLength;
string sText, sOldText;
object oApp, oDocs, oDoc, oSelection;

HomerRichTextBox rtb = this.Child.RTB;
if (rtb.SelectionLength == 0) {
AddMessage("All");
iStart = 0;
sText = rtb.Text;
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
sText = rtb.SelectedText;
}

if (sText.Length == 0) {
AddMessage("No text!");
return;
}

iEnd = iStart + sText.Length;
sText = sText.TrimEnd();
sOldText = sText;
sText = Util.Convert2MacLineBreak(sText);

bool bAppVisible = true;
//oApp = COM.GetOrCreateObject("Word.Application", out bCreate);
oApp = COM.WordAccess(out bCreate);
bVisible = (bool) COM.GetProperty(oApp, "Visible");
iDisplayAlerts = (int) COM.GetProperty(oApp, "DisplayAlerts");
COM.SetProperty(oApp, "Visible", bAppVisible);
COM.SetProperty(oApp, "DisplayAlerts", 0);
oDocs = COM.GetProperty(oApp, "Documents");
oDoc = COM.CallMethod(oDocs, "Add");
COM.CallMethod(oDoc, "Activate");
oSelection = COM.GetProperty(oApp, "Selection");
COM.CallMethod(oSelection, "TypeText", sText);
Util.ActivateProcess("WinWord");
COM.CallMethod(oDoc, "CheckSpelling");
iLength = (int) COM.GetProperty(oSelection, "StoryLength");
COM.CallMethod(oSelection, "SetRange", new object[] {0, iLength});
sText = (string) COM.GetProperty(oSelection, "Text");
sText = sText.Trim();
COM.Release(ref oSelection);
VB.WordClose(oDoc);
COM.Release(ref oDoc);
COM.Release(ref oDocs);
if (bCreate) {
//VB.WordQuit(oApp);
}
else {
COM.SetProperty(oApp, "Visible", bVisible);
COM.SetProperty(oApp, "DisplayAlerts", iDisplayAlerts);
}
COM.Release(ref oApp);

App.Frame.Activate();
App.Frame.Child.RTB.Select();
sText = Util.Convert2UnixLineBreak(sText);
if (sText == sOldText) AddMessage("No changes!");
else {
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
//AddMessage("Done!");
}
} // SpellCheck method

public void Thesaurus() {
bool bCreate, bVisible;
int iDisplayAlerts, iStart, iEnd, iLength;
string sText, sOldText;
object[] aResults;
object oApp, oDocs, oDoc, oSelection, oRange;

HomerRichTextBox rtb = this.Child.RTB;
if (rtb.SelectionLength == 0) {
AddMessage("Chunk");
aResults = GetChunk();
iStart = (int) aResults[0];
sText = (string) aResults[1];
}
else {
AddMessage("Selected");
iStart = rtb.SelectionStart;
sText = rtb.SelectedText;
}

iEnd = iStart + sText.Length;
sText = sText.TrimEnd();
if (sText.Length == 0) {
AddMessage("No text!");
return;
}

sOldText = sText;
sText = Util.Convert2MacLineBreak(sText);

bool bAppVisible = true;
//oApp = COM.GetOrCreateObject("Word.Application", out bCreate);
oApp = COM.WordAccess(out bCreate);
bVisible = (bool) COM.GetProperty(oApp, "Visible");
iDisplayAlerts = (int) COM.GetProperty(oApp, "DisplayAlerts");
COM.SetProperty(oApp, "Visible", bAppVisible);
COM.SetProperty(oApp, "DisplayAlerts", 0);
oDocs = COM.GetProperty(oApp, "Documents");
oDoc = COM.CallMethod(oDocs, "Add");
oSelection = COM.GetProperty(oApp, "Selection");
COM.CallMethod(oSelection, "TypeText", sText);
oRange = COM.GetProperty(oSelection, "Range");
Util.ActivateProcess("WinWord");
COM.CallMethod(oRange, "CheckSynonyms");
iLength = (int) COM.GetProperty(oSelection, "StoryLength");
COM.CallMethod(oSelection, "SetRange", new object[] {0, iLength});
sText = (string) COM.GetProperty(oSelection, "Text");
sText = sText.Trim();
COM.Release(ref oRange);
COM.Release(ref oSelection);
VB.WordClose(oDoc);
COM.Release(ref oDoc);
COM.Release(ref oDocs);
if (bCreate) {
//VB.WordQuit(oApp);
}
else {
COM.SetProperty(oApp, "Visible", bVisible);
COM.SetProperty(oApp, "DisplayAlerts", iDisplayAlerts);
}
COM.Release(ref oApp);

App.Frame.Activate();
App.Frame.Child.RTB.Select();
sText = Util.Convert2UnixLineBreak(sText);
if (sText == sOldText) AddMessage("No changes!");
else {
rtb.ReplaceRange(iStart, iEnd, sText);
rtb.Index = iStart;
//AddMessage("Done!");
}
} // Thesaurus method

public void ElevateVersion() {
string sDir = Environment.GetFolderPath(Environment.SpecialFolder.InternetCache);
string sName = "edsetup.exe";
string sUrl = @"http://www.EmpowermentZone.com/" + sName;
string sFile = Path.Combine(sDir, sName);

string sMsg = "download from\n" + sUrl + "\nto Internet cache, and run installer?";
if (Dialog.Confirm("Confirm", sMsg, "Y") != "Y") return;
Util.Say("Please wait");
try {
File.Delete(sFile);
if (!Win32.Url2File(sUrl, sFile)) {
Dialog.Show("Error!", "Cannot download file");
return;
}
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}
Util.Say("Exiting EdSharp and running installer");
//Process.Start(sFile);
Util.Run(Util.Quote(sFile));
Application.Exit();
} // ElevateVersion method

public bool ExitApp() {
while (this.Child != null) {
if (!CloseWindow(this.Child)) return false;
}
Application.Exit();
return true;
} // ExitApp method

public bool CloseWindow(MdiChild child) {
HomerRichTextBox rtb = child.RTB;
if (rtb.Modified) {
switch (Dialog.Confirm("Confirm", "Save changes to " + child.Text + "?", "Y")) {
case "Y" :
menuFileSave.PerformClick();
if (rtb.Modified) return false;
else break;
case "" :
return false;
}
}

child.Close();
return true;
} // CloseWindow method

public void SetRecent(string sFile) {
if (!sFile.Contains(@"\")) return;

DateTime dt = DateTime.Now;
string sTime = dt.ToString("u");
sTime = sTime.Substring(0, sTime.Length - 1);
sTime += "|" + (this.Child.RTB.ReadOnly ? "G" : "M") + "|" + Util.If(this.Child.RTB.WordWrap, "W", "U");
App.WriteValue("Recent", sFile, sTime);
} // SetRecent method

bool ApplyWrap(string sSection, string sFile) {
string sText = App.ReadValue(sSection, sFile, "");
if (sText.Length == 0) return false;

HomerRichTextBox rtb = this.Child.RTB;
sText = App.ReadOption("WordWrap", "Y");
sText = "-1|M|" + Util.If((sText == "N"), "U", "W");
sText = App.ReadValue(sSection, sFile, sText);
bool b = (bool) Util.If(sText.EndsWith("U"), false, true);
if (b && !rtb.WordWrap) {
AddMessage("Word wrap");
rtb.SetWrap(true);
}
else if (!b && rtb.WordWrap) {
AddMessage("Unwrap");
rtb.SetWrap(false);
}
return true;
} // ApplyWrap method

bool ApplyGuard(string sSection, string sFile) {
string sText = App.ReadValue(sSection, sFile, "");
if (sText.Length == 0) return false;

HomerRichTextBox rtb = this.Child.RTB;
sText = App.ReadOption("WordWrap", "Y");
sText = "-1|M|" + Util.If((sText == "N"), "U", "W");
sText = App.ReadValue(sSection, sFile, sText);
if (sText.IndexOf("G") >= 0) {
AddMessage("Guard");
rtb.SetGuard(true);
}
return true;
} // ApplyGuard method

public void ApplyFileOptions(string sFile) {
if (!ApplyGuard("Favorites", sFile)) ApplyGuard("Recent", sFile);
if (!ApplyWrap("Favorites", sFile)) {
ApplyWrap("Recent", sFile);
return;
}

HomerRichTextBox rtb = this.Child.RTB;
string sText = App.ReadValue("Favorites", sFile, "");
try {
string[] a = sText.Split('|');
sText = a[0];
rtb.Index = Int32.Parse(sText);
AddMessage("Bookmark at percent " + rtb.Percent);
}
catch {}
} // ApplyFavorite method

public void OpenOrActivateWindow(string sFile) {
int iConvert = 0;
OpenOrActivateWindow(sFile, iConvert);
} // OpenOrActivateWindow method

public void OpenOrActivateWindow(string sFile, int iConvert) {
string sText;
sFile = Util.Unquote(sFile);
object[] children = this.MdiChildren;
foreach (MdiChild child in children) {
if (Util.Equiv(child.File, sFile)) {
Util.Say("returning");
child.Activate();
return;
}
}

sText = COM.ConvertFile2String(sFile, ref iConvert);
if (iConvert == 2 && sText.Trim().Length == 0) {
AddMessage("No text!");
return;
}

if (!IsEmptyWindow()) new MdiChild(this);
if (iConvert == 0) {
this.Child.LoadTextFile(sFile);
ApplyFileOptions(sFile);

if (sFile == App.IniFile) return;
}
else {
this.Child.RTB.Text = sText;
this.Child.Text = Path.GetFileNameWithoutExtension(sFile) + ".txt";
this.Child.RTB.Modified = false;
}
SetRecent(sFile);
//Dialog.Show(sFile);
} // OpenOrActivateWindow method

public void NextWindow() {
object[] children = this.MdiChildren;
if (children.Length == 0) AddMessage("No windows!");
else if (children.Length == 1) AddMessage("Only this window!");
else {
MdiChild child = this.Child;
int iPosition = Array.IndexOf(children, child);
iPosition++;
if (iPosition == children.Length) iPosition = 0;
((MdiChild) children[iPosition]).Activate();
}
} // NextWindow method

public void PriorWindow() {
object[] children = this.MdiChildren;
if (children.Length == 0) AddMessage("No windows!");
else if (children.Length == 1) AddMessage("Only this window!");
else {
MdiChild child = this.Child;
int iPosition = Array.IndexOf(children, child);
iPosition--;
if (iPosition == -1) iPosition = children.Length - 1;
((MdiChild) children[iPosition]).Activate();
}
} // PriorWindow method

public void CloseAllButCurrentWindow() {
MdiChild child = this.Child;
if (child == null) return;

object[] children = this.MdiChildren;
int iCount = 0;
foreach (MdiChild o in children) {
if (o != child) {
o.Close();
iCount++;
}
}
} // CloseAllButCurrent method

public void WindowsOpen() {
object[] children = this.MdiChildren;
int iCount = children.Length;
if (iCount == 0) AddMessage("No windows!");
else {
//string s = Util.Pluralize(iCount, "window");
AddMessage(iCount);
foreach (MdiChild child in children) {
string sTitle = child.Text;
AddMessage(sTitle);
}
}
} // WindowsOpen method

public void NavigateNextMatch(string sMatch) {
bool bLine = false;
NavigateNextMatch(sMatch, bLine);
} // NavigateNextMatch method

public void NavigateNextMatch(string sMatch, bool bLine) {
int iIndex, iStart, iEnd, iForward;
string sValue, sText;
object[] aResults;
HomerRichTextBox rtb = this.Child.RTB;
iIndex = rtb.Index;
iStart = iIndex;
iEnd = rtb.TextLength;
sText = rtb.GetRange(iStart, iEnd);
aResults = Util.RegExpContainsCase(sText, sMatch);
if ((int) aResults[0] == -1) {
this.AddMessage("Bottom!");
iStart = iEnd;
iIndex = iEnd;
}
else {
iForward = (int) aResults[0];
sValue = (string) aResults[1];
iIndex += iForward + sValue.Length;
iStart = iIndex;
sText = rtb.GetRange(iStart, iEnd);
aResults = Util.RegExpContainsCase(sText, sMatch);
if ((int) aResults[0] == -1) {
}
else {
iForward = (int) aResults[0];
sValue = (string) aResults[1];
iEnd = iStart + iForward + sValue.Length;
}
}

if (bLine) {
sText = rtb.RowText;
rtb.Index = iIndex;
rtb.Col = 0;
}
else {
sText = rtb.GetRange(iStart, iEnd);
rtb.Index = iIndex;
}
this.AddMessage(sText);
} // NavigateNextMatch method

public void NavigatePriorMatch(string sMatch) {
bool bLine = false;
NavigatePriorMatch(sMatch, bLine);
} // NavigatePriorMatch method

public void NavigatePriorMatch(string sMatch, bool bLine) {
int iIndex, iStart, iEnd, iBackward;
string sValue, sText;
object[] aResults;
HomerRichTextBox rtb = this.Child.RTB;
iIndex = rtb.Index;
//iIndex++;
iStart = 0;
iEnd = iIndex;
sText = rtb.GetRange(iStart, iEnd);
aResults = Util.RegExpContainsLastCase(sText, sMatch);
if ((int) aResults[0] == -1) {
this.AddMessage("Top!");
iIndex = iStart;
iEnd = iStart;
}
else {
iBackward = (int) aResults[0];
sValue = (string) aResults[1];
//Dialog.Show(iBackward, sValue);
iEnd = iBackward;
sText = rtb.GetRange(iStart, iEnd);
aResults = Util.RegExpContainsLastCase(sText, sMatch);
if ((int) aResults[0] == -1) {
iIndex = iStart;
}
else {
iBackward = (int) aResults[0];
sValue = (string) aResults[1];
//Dialog.Show(iBackward, sValue);
iStart = iBackward + sValue.Length;
iIndex = iStart;
}
}

if (bLine) {
sText = rtb.RowText;
rtb.Col = 0;
}
else {
sText = rtb.GetRange(iStart, iEnd);
rtb.Index = iIndex;
}
this.AddMessage(sText);
} // NavigatePriorMatch method

public void FileFind() {
string sContains, sFilter, sDir, sFile;
string[] aLabels, aValues, aFilters, aResults, aFiles, aNames;

sContains = App.ReadData("Contains", "");
sFilter = App.ReadData("Filter", "*.*");
string sTitle = "Open Folder";
sDir = Dialog.OpenFolder(sTitle, "Name", Directory.GetCurrentDirectory());
if (sDir.Length == 0) return;

Directory.SetCurrentDirectory(sDir);
aLabels = new string[] {"&Contains", "&Filter"};
aValues = new string[] {sContains, sFilter};
aResults = Dialog.MultiInput("Criteria", aLabels, aValues);
if (aResults.Length == 0) return;

sContains = aResults[0];
sFilter = aResults[1].Trim();
if (sFilter.Length == 0) sFilter = "*.*";
App.WriteData("Contains", sContains);
App.WriteData("Filter", sFilter);
aFilters = sFilter.Split('|');
sDir = Directory.GetCurrentDirectory();
aFiles = Util.FindInFiles(sContains, sDir, aFilters, false);
if (aFiles.Length == 0) {
Dialog.Show("Alert", "No matches!");
return;
}

aNames = new string[aFiles.Length];
for (int i = 0; i < aNames.Length; i++) aNames[i] = Path.GetFileName(aFiles[i]);
//Array.Sort(aNames, aFiles);
sFile = Dialog.Pick("Pick", aFiles, aNames, true, 0);
if (sFile.Length == 0) return;

OpenOrActivateWindow(sFile, 1);
/*
string[] aNames = null;
string[] aPaths = null;
int iIndex = -1;
string sPath = "";
string sName = "";
string sPaths = "";
string sNames = "";

string sDir = Directory.GetCurrentDirectory();
string sMatch = App.ReadData("FileFindMatch", "");
string sFilter = App.ReadData("FileFindFilter", "");
string sFields = "&Text\t&Filter";
string sValues = sMatch + "\t" + sFilter;
string[] aFields = sFields.Split('\t');
string[] aValues = sValues.Split('\t');
string[] aResults = Dialog.MultiInput("File Find", aFields, aValues);
if (aResults.Length == 0) return;

sMatch = aResults[0];
sFilter = aResults[1];
if (true) {
//if (sDir == App.sFileFindDir && sMatch == App.sFileFindMatch && sFilter == App.sFileFindFilter) {
AddMessage("Repeat search");
//aNames = App.aFileFind;
//iIndex = App.iFileFind + 1;
if (iIndex == -1) iIndex = 0;
}
else {
AddMessage("Please wait");
//ReadOnlyCollection<string> oPaths = null;
string[] aPaths = Util.GetFiles(sDir);
//if (sMatch == "") oPaths = LbcVB.GetFiles(sDir, sFilter);
//else oPaths = LbcVB.FindInFiles(sDir, sMatch, sFilter);
//if (oPaths.Count == 0) {
AddMessage("No files found!");
return;
}
//foreach (string s in oPaths) {
foreach (string s in aPaths) {
sPaths += s + "\n";
sName = s.Substring(sDir.Length + 1);
sNames += sName + "\n";
}
aPaths = sPaths.Trim().Split('\n');
aNames = sNames.Trim().Split('\n');
iIndex = 0;
}

App.WriteData("FileFindMatch", sMatch);
App.WriteData("FileFindFilter", sFilter);
sName = Dialog.Pick("Pick", aNames, true, iIndex);
if (sName.Length == 0) return;

int iName = Array.IndexOf(aNames, sName);
App.WriteData("FileFindDir", sDir);
App.aFileFind = aNames;
App.iFileFind = iName;
sPath = aPaths[iName];
sDir = Path.GetDirectoryName(sPath);
if (sDir.Length == 0) return;
if (Directory.Exists(sDir)) {
OpenOrActivateWindow(sFile, 1);
}
else AddMessage("Folder " + sDir + " not found!");
*/
} //FileFind method

public void CurrentWindows() {
object[] children = this.MdiChildren;
string sTitles = "";
foreach (MdiChild child in children) {
sTitles += child.Text + "\n";
}
string[] aTitles = sTitles.Trim().Split('\n');
string sTitle = Dialog.Pick("Current Windows", aTitles, true, 0);
if (sTitle.Length == 0) return;

int iTitle = Array.IndexOf(aTitles, sTitle);
((MdiChild) children[iTitle]).Activate();
} // CurrentWindows method

public void ExplorerFolder() {
this.SetStatus("Explorer folder");
string sCommand = Directory.GetCurrentDirectory();
try {
Process.Start(sCommand);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}
} // ExplorerFolder method

public void CommandPrompt() {
this.SetStatus("Command prompt");
string sCommand = "cmd.exe";
string sParams = "/k";
try {
Process.Start(sCommand, sParams);
}
catch (Exception ex) {
Dialog.Show("Error!", ex.Message);
return;
}
} // CommandPrompt method

public void AlternateMenu() {
int iChoice = -1;
List<ToolStripMenuItem> items = new List<ToolStripMenuItem>();
string sItems = "";
StringBuilder sb = new StringBuilder();
foreach (ToolStripMenuItem menu in menuMain.Items) {
foreach (object o in menu.DropDownItems) {
ToolStripMenuItem item = o as ToolStripMenuItem;
if (item == null) continue;
if (item == menuHelpAlternateMenu) continue;
string sText = item.Text.Replace("&", "");
if ("1234567890".Contains(sText.Substring(0, 1))) continue;
sb.Append(sText + "\n");
items.Add(item);
}
}
sItems = sb.ToString();
string[] aItems = sItems.Trim().Split('\n');
string sItem = Dialog.Pick("Alternate Menu", aItems, true, 0);
if (sItem.Length == 0) return;

foreach (ToolStripMenuItem item in items) {
if (sItem == item.Text.Replace("&", "")) {
iChoice = items.IndexOf(item);
break;
}
}
items[iChoice].PerformClick();
} // AlternateMenu method

new void ContextMenu(string sFile) {
MdiChild child = this.Child;
string[] aVerbs = COM.Verbs(sFile);
Array.Resize(ref aVerbs, aVerbs.Length + 1);
aVerbs[aVerbs.Length - 1] = "Open With...";
string[] aNames = new string[aVerbs.Length];
for (int iVerb = 0; iVerb < aVerbs.Length; iVerb++) aNames[iVerb] = aVerbs[iVerb].Replace("&", "");

string sName = Dialog.Pick("Context Menu", aNames, true, 0);
if (sName.Length == 0) return;

int i = Array.IndexOf(aNames, sName);
string sVerb = aVerbs[i];

if (sVerb == "Open With...") Win32.OpenWith(sFile);
else COM.InvokeVerb(sFile, sVerb);
} // ContextMenu method

public void SendToMenu(string sFile) {
MdiChild child = this.Child;
string sDir = Environment.GetFolderPath(Environment.SpecialFolder.SendTo);
string[]aLinks = Directory.GetFiles(sDir);
string sNameList = "";
foreach (string s in aLinks) sNameList += Path.GetFileNameWithoutExtension(s) + "\n";
string[]aNames = sNameList.Trim().Split('\n');
string sName = Dialog.Pick("SendTo Menu", aNames, true, 0);
if (sName.Length == 0) return;

int i = Array.IndexOf(aNames, sName);
string sLink = aLinks[i];

Process.Start(sLink, sFile);
} // SendToMenu method

} // MdiFrame class

public class HomerRichTextBox : RichTextBox {
public static string CR = "\r";
public static string LF = "\n";
public static string LB = LF;
public static string LineBreak = Environment.NewLine;
public static string FF = "\f";
public static string SB = FF + LB;
public static string DD = "----------";
public static string SectionBreak = LB + DD + LB + SB;
public static string EOD = LB + DD + LB + "End of Document" + LB;

public bool IndentMode = false;
public int IndentLevels = 0;
public int Index {
get {
return this.SelectionStart + this.SelectionLength;
}
set {
this.DeselectAll();
this.SelectionStart = value;
this.ScrollToCaret();
this.Update();
this.Refresh();
Application.DoEvents();
System.Threading.Thread.Sleep(100);
//this.OnNotifyMessage();
//this.OnSelectionChanged();
}
} // Index property

public int Row {
get {
return this.GetLineFromCharIndex(this.Index);
}  
set {
int iIndex = this.GetFirstCharIndexFromLine(value);
this.DeselectAll();
this.SelectionStart = iIndex;
}
} // Row property

public int Col {
get {
return this.Index - this.GetFirstCharIndexOfCurrentLine();
}
set {
this.Index = GetFirstCharIndexOfCurrentLine() + value;
}
} // Col property

public int RowStart {
get {
return this.GetFirstCharIndexOfCurrentLine();
}
set {
}
} // RowStart property

public string RowText {
get {
return this.GetRowText(this.Row);
}
set {
}
} // RowText property

public int RowEnd {
get {
return this.RowStart + this.RowText.Length;
}
set {
}
} // RowEnd property

public int Line {
get {
return this.Row + 1;
}
set {
this.Row = value - 1;
}
} // Line property

public int Column {
get {
return this.Col + 1;
}
set {
this.Col = value - 1;
}
} // Column property

public double Percent {
get {
if (this.Text.Length == 0) return 0;
else return Math.Round((double) ((100.0 * this.Index) / this.Text.Length), 1);
}
set {
int iIndex = (int) ((this.Text.Length * value) / 100.0);
this.DeselectAll();
this.SelectionStart = iIndex;
}
} // Percent property

public void SetRowAndCol(int iRow, int iCol) {
int iRowStart = this.GetFirstCharIndexFromLine(iRow);
int iIndex = iRowStart + iCol;
this.DeselectAll();
this.SelectionStart = iIndex;
} // SetRowAndCol method

public void SetLineAndColumn(int iLine, int iColumn) {
int iRow = iLine - 1;
int iCol = iColumn - 1;
this.SetRowAndCol(iRow, iCol);
} // SetLineAndColumn method

public string GetRange(int iStart, int iEnd) {
int iLength = iEnd - iStart ;
string sText = this.Text;
return sText.Substring(iStart, iLength);
} // GetRange method

public void ReplaceRange(int iStart, int iEnd, string sText) {
this.DeselectAll();
this.Select(iStart, iEnd - iStart);
this.SelectedText = sText;
this.Index = iStart + sText.Length;
} // ReplaceRange method

public void SelectRange(int iStart, int iEnd) {
this.DeselectAll();
this.Select(iStart, iEnd - iStart);
} // SelectRange method

private int iStartSelection;
public int StartSelection {
get {
return iStartSelection;
}
set {
iStartSelection = value;
}
} // StartSelection property

private int iBookmark;
public int Bookmark {
get {
return iBookmark;
}
set {
iBookmark = value;
}
} // Bookmark property

private string sFindText;
public string FindText {
get {
return sFindText;
}
set {
sFindText = value;
}
} // FindText property

private string sMatchText;
public string MatchText {
get {
return sMatchText;
}
set {
sMatchText = value;
}
} // MatchText property

private string sReplaceText;
public string ReplaceText {
get {
return sReplaceText;
}
set {
sReplaceText = value;
}
} // ReplaceText property

private string sPatternText;
public string PatternText {
get {
return sPatternText;
}
set {
sPatternText = value;
}
} // PatternText property

private string sSubstituteText;
public string SubstituteText {
get {
return sSubstituteText;
}
set {
sSubstituteText = value;
}
} // SubstituteText property

private string sJumpLine;
public string JumpLine {
get {
return sJumpLine;
}
set {
sJumpLine = value;
}
} // JumpLine property

private string sGoPercent;
public string GoPercent {
get {
return sGoPercent;
}
set {
sGoPercent = value;
}
} // GoPercent property

private string sSearchTopic;
public string SearchTopic {
get {
return sSearchTopic;
}
set {
sSearchTopic = value;
}
} // SearchTopic property

private int iOldSelectionStart;
public int OldSelectionStart {
get {
return iOldSelectionStart;
}
set {
iOldSelectionStart = value;
}
} // OldSelectionStart property

private int iOldSelectionLength;
public int OldSelectionLength {
get {
return iOldSelectionLength;
}
set {
iOldSelectionLength = value;
}
} // OldSelectionLength property

public void StoreSelection() {
this.OldSelectionStart = this.SelectionStart;
this.OldSelectionLength = this.SelectionLength;
this.DeselectAll();
this.Index = this.OldSelectionStart + this.OldSelectionLength;
} // StoreSelection method

public void Reselect() {
this.DeselectAll();
this.Select(this.OldSelectionStart, this.OldSelectionLength);
} // Reselect method

public bool IsBottomRow {
get {
int iIndex = GetFirstCharIndexFromLine(this.Row + 1);
return iIndex < 0;
}
set {
}
} // IsBottomRow property

public int BottomRow {
get {
return this.Text.Split('\n').Length - 1;
}
set {
}
} // BottomRow property

public int RowLength {
get {
int iRow = this.Row;
int iStart = GetFirstCharIndexFromLine(iRow);
int iEnd = GetFirstCharIndexFromLine(iRow + 1);
//if (iEnd <= 0) iEnd = iStart;
if (iEnd <= 0) iEnd = this.TextLength;
;
int iLength = iEnd - iStart;
/*
int iLength = this.Lines[this.Row].Length;
if (!this.IsBottomRow) iLength++;
*/
return iLength;
}
set {
}
} // RowLength property

public HomerRichTextBox() {
} // HomerRichTextBox constructor

public string GetRowText(int iRow) {
int iStart = this.GetFirstCharIndexFromLine(iRow);
int iEnd = this.GetFirstCharIndexFromLine(iRow + 1);
if (iEnd == -1) iEnd = this.Text.Length;
return this.GetRange(iStart, iEnd);
} // GetRowText method

public bool SetWrap(bool bWrap) {
bool bOldWrap = this.WordWrap;
bool bModified = this.Modified;
this.WordWrap = bWrap;
this.Modified = bModified;
return bOldWrap;
} // SetWrap method

public bool SetGuard(bool bGuard) {
bool bOldGuard = this.ReadOnly;
bool bModified = this.Modified;
this.ReadOnly = bGuard;
this.Modified = bModified;
return bOldGuard;
} // SetGuard method

protected override bool ProcessCmdKey(ref Message msg, Keys keyData) {
return App.Frame.ProcessCmdKey_Helper(ref msg, keyData);
} // ProcessCmdKey handler

} // HomerRichTextBox class

public class Dialog {

public static string OpenFile(string sTitle, string sPath) {
string sReturn = "";
string sDir;

OpenFileDialog dlg = new OpenFileDialog();
if (File.Exists(sPath)) {
dlg.FileName = sPath;
sDir = Path.GetDirectoryName(sPath);
}
else sDir = sPath;

if (Directory.Exists(sDir)) dlg.InitialDirectory = sDir;
dlg.Filter = "All files (*.*)|*.*|Text files (*.txt)|*.txt|Rich Text Format files (*.rtf)|*.rtf";
dlg.FilterIndex = 1;
dlg.ValidateNames = true;
dlg.CheckPathExists = true;

if (dlg.ShowDialog() == DialogResult.OK) sReturn = dlg.FileName;
dlg.Dispose();
return sReturn;
} // OpenFile method

public static string SaveFile(string sTitle, string sPath) {
string sReturn = "";
string sDir;

SaveFileDialog dlg = new SaveFileDialog();
if (Directory.Exists(sPath)) sDir = sPath;
else {
dlg.FileName = sPath;
sDir = Path.GetDirectoryName(sPath);
}

if (Directory.Exists(sDir)) dlg.InitialDirectory = sDir;
dlg.Filter = "All files (*.*)|*.*|Text files (*.txt)|*.txt|Rich Text Format files (*.rtf)|*.rtf";
dlg.FilterIndex = 1;
dlg.CheckPathExists = true;
dlg.SupportMultiDottedExtensions = true;

dlg.CreatePrompt = false;
dlg.ValidateNames = true;
dlg.AddExtension = true;
//dlg.AddExtension = false;
dlg.DefaultExt = "txt";

if (dlg.ShowDialog() == DialogResult.OK) sReturn = dlg.FileName;
dlg.Dispose();
return sReturn;
} // SaveFile method

public static string OldInput(string sTitle, string sLabel, string sValue) {
return Interaction.InputBox(sLabel, sTitle, sValue, -1, -1);
} // Input method

public static string Input(string sTitle, string sLabel, string sValue) {
string[] aLabel = new string[] {sLabel};
string[] aValue = new string[] {sValue};
string[] aReturn = MultiInput(sTitle, aLabel, aValue);
//string sReturn = aReturn[0];
string sReturn = "";
if (aReturn != null && aReturn.Length > 0) sReturn = aReturn[0];
return sReturn;
} // Input method

public static string[] MultiInput(string sTitle, string[] aLabel, string[] aValue) {
Form frm = new Form();
frm.SuspendLayout();
frm.AutoSize = true;
frm.AutoSizeMode = AutoSizeMode.GrowAndShrink;
frm.AutoScroll = true;

FlowLayoutPanel flpMain = new FlowLayoutPanel();
flpMain.SuspendLayout();
flpMain.AutoSize = true;
flpMain.AutoSizeMode = AutoSizeMode.GrowAndShrink;
flpMain.AutoScroll = true;
flpMain.FlowDirection = FlowDirection.TopDown;

TableLayoutPanel tlpFields = new TableLayoutPanel();
tlpFields.SuspendLayout();
tlpFields.Anchor = AnchorStyles.None;
tlpFields.AutoSize = true;
tlpFields.AutoSizeMode = AutoSizeMode.GrowAndShrink;
tlpFields.AutoScroll = true;

tlpFields.ColumnCount = 2;

for (int i = 0; i < tlpFields.ColumnCount; i++) {
tlpFields.ColumnStyles.Add(new ColumnStyle(SizeType.AutoSize));
}

tlpFields.RowCount = aLabel.Length;

for (int i = 0; i < tlpFields.RowCount; i++) {
tlpFields.RowStyles.Add(new RowStyle(SizeType.AutoSize));
Label lbl = new Label();
lbl.Text = aLabel[i] + ":";
lbl.AccessibleName = lbl.Text.Replace("&", "");
TextBox txt = new TextBox();
txt.Text = aValue[i];
txt.AccessibleName = lbl.AccessibleName;
tlpFields.Controls.AddRange(new Control[] {lbl, txt});
}
tlpFields.ResumeLayout();

FlowLayoutPanel flpButtons = new FlowLayoutPanel();
flpButtons.SuspendLayout();
flpButtons.Anchor = AnchorStyles.None;
flpButtons.AutoSize = true;
flpButtons.AutoSizeMode = AutoSizeMode.GrowAndShrink;
flpButtons.AutoScroll = true;
flpButtons.FlowDirection = FlowDirection.LeftToRight;

Button btnOK = new Button();
btnOK.Text = "OK";
btnOK.AccessibleName = btnOK.Text;

StringBuilder sb = new StringBuilder();
btnOK.Click += delegate(object o, EventArgs e) {
foreach (Control ctl in tlpFields.Controls) {
if (ctl.GetType() == typeof(TextBox)) sb.Append(ctl.Text + "