/*
HomerLbc
Copyright 2009 - 2010 by Jamal Mazrui
GNU Lesser General Public License (LGPL)
*/

import Homer
import Accessibility
import Microsoft.VisualBasic
import Microsoft.VisualBasic.Compatibility.VB6
import Microsoft.VisualBasic.ApplicationServices
import Microsoft.VisualBasic.Devices
import Microsoft.VisualBasic.FileIO
import Microsoft.VisualBasic.Logging
import Microsoft.VisualBasic.MyServices
import Microsoft.Win32
import System
import System.Collections
import System.Collections.ObjectModel
import System.Collections.Specialized
import System.ComponentModel
import System.Data
import System.Data.OleDb
import System.Diagnostics
import System.Drawing
import System.IO
import System.Media
import System.Net
import System.Reflection
import System.Runtime.InteropServices
import System.Text
import System.Text.RegularExpressions
import System.Threading
import System.Web
import System.Windows.Forms
import System.Xml

package Homer {
class Lbc {
static var CodeFile = ''
static var ImportFile = ''
static var ExportFile = ''

static function CollectionToArray(oCollection) {
// Convert a collection to an array

var aReturn = []
var iCount = oCollection.Count
for (var o in oCollection) aReturn.push(o)
return aReturn
} // CollectionToArray method

static function DialogBrowseForFolder(sTitle: String): String {
var sDir = ''
return DialogBrowseForFolder(sTitle, sDir)
} // DialogBrowseForFolder method

static function DialogBrowseForFolder(sTitle: String, sDir: String): String {
// Get a folder path to browse

var sReturn = ''
var dlg = new FolderBrowserDialog()
if (sTitle) dlg.Description = sTitle
dlg.ShowNewFolderButton = true
dlg.SelectedPath = sDir

if (dlg.ShowDialog() == DialogResult.OK) sReturn = dlg.SelectedPath
dlg.Dispose()
return sReturn
} // BrowseForFolder method

static function DialogChoose(sTitle: String, sMessage: String, aButtons): String {
var iFocus = 0
var dTips = new Hashtable()
return DialogChoose(sTitle, sMessage, aButtons, iFocus, dTips)
} // DialogChoose method

static function DialogChoose(sTitle: String, sMessage: String, aButtons, iFocus: Int32): String {
var dTips = new Hashtable()
return DialogChoose(sTitle, sMessage, aButtons, iFocus, dTips)
} // DialogChoose method

static function DialogChoose(sTitle: String, sMessage: String, aButtons, iFocus: Int32, dTips: Hashtable): String {
// Choose a button

if (!sTitle) var sTitle = 'Choose'
if (!sMessage) var sMessage = ''
if (!aButtons) var aButtons = []
if (!iFocus) var iFocus = 0
if (!dTips) var dTips = new Hashtable()
aButtons.push('Cancel')

var dlg = new LbcForm(sTitle, 'this.HandleDialogChoose', dTips)
if (sMessage) {
dlg.AddLabel(sMessage)
dlg.AddBand()
} // if sMessage

for (var i = 0; i < aButtons.length; i++){
var sButton = aButtons[i]
var btn = dlg.AddButton(sButton)
if ((aButtons.length - i) > 1) dlg.AddBand()
}
dlg.CompleteDialog(null, iFocus)

var sReturn = dlg.Result
dlg.Dispose()
return sReturn
} // DialogChoose method

static function DialogConfirm(sTitle: String, sMessage: String): String {
var sDefault = 'Y'
return DialogConfirm(sTitle, sMessage, sDefault)
} // DialogConfirm method

static function DialogConfirm(sTitle: String, sMessage: String, sDefault: String): String {
// Confirm the answer to a Yes/No question

if (!sTitle) sTitle = 'Confirm'
if (!sMessage) sMessage = ''
var defaultButton = MessageBoxDefaultButton.Button1
if (sDefault.ToLower() == 'n') defaultButton = MessageBoxDefaultButton.Button2
switch (MessageBox.Show(sMessage, sTitle, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question, defaultButton)) {
case DialogResult.Yes :
return 'Y'
case DialogResult.No :
return 'N'
}
return ''
} // DialogConfirm method

static function DialogDatePicker(sTitle: String): DateTime {
var sLabel = ''
var dtValue = null
var dtMinValue = null
var dtMaxValue = null
var dTips = new Hashtable()
return DialogDatePicker(sTitle, sLabel, dtValue, dtMinValue, dtMaxValue, dTips)
} // DialogDatePicker method

static function DialogDatePicker(sTitle: String, sLabel: String, dtValue, dtMinValue, dtMaxValue): DateTime {
var dTips = new Hashtable()
return DialogDatePicker(sTitle, sLabel, dtValue, dtMinValue, dtMaxValue, dTips)
} // DialogDatePicker method

static function DialogDatePicker(sTitle: String, sLabel: String, dtValue, dtMinValue, dtMaxValue, dTips: Hashtable): DateTime {
// Pick a date value

if (!sTitle) var sTitle = 'DateTime Pick'
if (!sLabel) var sLabel = ''
if (!dtValue) var dtValue = null
if (!dtMinValue) var dtMinValue = null
if (!dtMaxValue) var dtMaxValue = null
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogDatePicker', dTips)
var dtp:DateTimePicker = dlg.AddDatePickerBox(sLabel, dtValue, dtMinValue, dtMaxValue, sTip)
dlg.CompleteDialog([])

var dtReturn = dlg.Result
dlg.Dispose()
return dtReturn
} // DialogDatePicker method

static function DialogInfo(sTitle: String, sLabel: String, sText: String) {
var dTips = new Hashtable()
return DialogInfo(sTitle, sLabel, sText, dTips)
} // DialogInfo method

static function DialogInfo(sTitle: String, sLabel: String, sText: String, dTips: Hashtable) {
// Show multiple lines of scrollable information

if (!sTitle) var sTitle = 'Info'
if (!sLabel) var sLabel = ''
if (!sText) var sText = ''
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogInfo', dTips)
var memo = dlg.AddMemoBox(sLabel, sText, true, sTip)
var aButtons = ['Close']
dlg.CompleteDialog(aButtons)
dlg.Dispose()
return null
} // DialogInfo method

static function DialogInput(sTitle: String): String {
var sName = ''
var sValue = ''
var dTips = new Hashtable()
return DialogInput(sTitle, sName, sValue, dTips)
} // DialogInput method

static function DialogInput(sTitle: String, sName: String): String {
var sValue = ''
var dTips = new Hashtable()
return DialogInput(sTitle, sName, sValue, dTips)
} // DialogInput method

static function DialogInput(sTitle: String, sName: String, sValue: String): String {
var dTips = new Hashtable()
return DialogInput(sTitle, sName, sValue, dTips)
} // DialogInput method

static function DialogInput(sTitle: String, sName: String, sValue: String, dTips: Hashtable): String {
// Input a value

if (!sTitle) var sTitle = 'Input'
var aNames = [sName]
var aValues = [sValue]
var iFocus = 0
var dTips = new Hashtable()
var aResults = Lbc.DialogMultiInput(sTitle, aNames, aValues, iFocus, dTips)
var sResult = null
if (aResults && aResults.length) sResult = aResults[0]
return sResult
} // DialogInput method

static function DialogInputAndChoose(sTitle: String, sName: String, sValue: String, aButtons): String[] {
var iFocus = 0
var dTips = new Hashtable()
return DialogInputAndChoose(sTitle, sName, sValue, aButtons, iFocus, dTips)
} // DialogInputAndChoose method

static function DialogInputAndChoose(sTitle: String, sName: String, sValue: String, aButtons, iFocus: Int32): String[] {
var dTips = new Hashtable()
return DialogInputAndChoose(sTitle, sName, sValue, aButtons, iFocus, dTips)

} // DialogInputAndChoose method

static function DialogInputAndChoose(sTitle: String, sName: String, sValue: String, aButtons, iFocus: Int32, dTips: Hashtable): String[] {
// Input a value and choose a button

if (!sTitle) var sTitle = 'Input and Choose'
if (!aButtons) var aButtons = []
if (!sName) var sName = ''
if (!sValue) var sValue = ''
if (!iFocus) var iFocus = 0
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogInputAndChoose', dTips)
dlg.AddInputBox(sName, sValue, sTip)
aButtons.push('Cancel')
dlg.CompleteDialog(aButtons, iFocus)

var aReturn = dlg.Result
dlg.Dispose()
return aReturn
} // DialogInputAndChoose method

static function DialogMemo(sTitle: String): String {
var sLabel = ''
return DialogMemo(sTitle, sLabel)
} // DialogMemo method

static function DialogMemo(sTitle: String, sLabel: String): String {
var sText = ''
var dTips = new Hashtable()
return DialogMemo(sTitle, sLabel, sText, dTips)
} // DialogMemo method

static function DialogMemo(sTitle: String, sLabel: String, sText: String): String {
var dTips = new Hashtable()
return DialogMemo(sTitle, sLabel, sText, dTips)
} // DialogMemo method

static function DialogMemo(sTitle: String, sLabel: String, sText: String, dTips: Hashtable): String {
// Edit a multiline memo

if (!sTitle) var sTitle = 'Memo'
if (!sLabel) var sLabel = ''
if (!sText) var sText = ''
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogMemo', dTips)
var memo = dlg.AddMemoBox(sLabel, sText, false, sTip)
dlg.CompleteDialog([])
return dlg.Result
} // DialogMemo method

static function DialogMultiCheck(sTitle: String, sLabel: String, aNames): Object[] {
var aValues = aNames
var aSelect = Jax.JsInitArray(false, aNames.length)
var bSort = false
var iIndex = 0
var dTips = new Hashtable()
return DialogMultiCheck(sTitle, sLabel, aNames, aValues, aSelect, bSort, iIndex, dTips)
} // DialogMultiCheck method

static function DialogMultiCheck(sTitle: String, sLabel: String, aNames, aValues, aSelect, bSort: Boolean, iIndex: Int32): Object[] {
var dTips = new Hashtable()
return DialogMultiCheck(sTitle, sLabel, aNames, aValues, aSelect, bSort, iIndex, dTips)
} // DialogMultiCheck method

static function DialogMultiCheck(sTitle: String, sLabel: String, aNames, aValues, aSelect, bSort: Boolean, iIndex: Int32, dTips: Hashtable): Object[] {
// Check multiple values

if (!sTitle) var sTitle = 'Multi Check'
if (!sLabel) var sLabel = ''
if (!aNames) var aNames = []
if (!aValues) var aValues = aNames
if (!aSelect) var aSelect = Jax.JsInitArray(false, aNames.length)
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogMultiCheck', dTips)
dlg.ItemTips = aValues
var lst:CheckedListBox = dlg.AddMultiCheckBox(sLabel, aNames, aSelect, bSort, iIndex, dTips)
if (bSort) lst.Sorted = true
if (iIndex >= 0 && lst.Items.Count) lst.SelectedIndex = iIndex
dlg.CompleteDialog([])

var aResults = dlg.Result
dlg.Dispose()
var aReturn = []
for (var i = 0; i < aResults.length; i++) {
var iIndex = aResults[i]
var oValue = aValues[iIndex]
aReturn.push(oValue)
}
return aReturn
} // DialogMultiCheck method

static function DialogMultiInput(sTitle: String, aNames): String[] {
var aValues = Jax.JsInitArray('', aNames.length)
return DialogMultiInput(sTitle, aNames, aValues)
} // DialogMultiInput method

static function DialogMultiInput(sTitle: String, aNames, aValues): String[] {
var iFocus = 0
var dTips = new Hashtable()
return DialogMultiInput(sTitle, aNames, aValues, iFocus, dTips)
} // DialogMultiInput method

static function DialogMultiInput(sTitle: String, aNames, aValues, iFocus: Int32): String[] {
var dTips = new Hashtable()
return DialogMultiInput(sTitle, aNames, aValues, iFocus, dTips)
} // DialogMultiInput method

static function DialogMultiInput(sTitle: String, aNames, aValues, iFocus: Int32, dTips: Hashtable): String[] {
// Input multiple values

if (!sTitle) var sTitle = 'Multi Input'
if (!aNames) var aNames = []
if (!aValues) var aValues = Jax.JsInitArray('', aNames.length)
if (!iFocus) var iFocus = 0
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogMultiInput', dTips)
for (var i = 0; i < aNames.length; i++){
var sName = aNames[i]
var sValue = aValues[i]
var txt:TextBox = dlg.AddInputBox(sName, sValue, sTip)
if (aNames.length - i > 1) dlg.AddBand()
}
dlg.CompleteDialog([], iFocus)

var aReturn = dlg.Result
dlg.Dispose()
return aReturn
} // DialogMultiInput method

static function DialogMultiMaskedInput(sTitle: String, aNames, aValues, aMasks): String[] {
var aTypes = []
var iFocus = 0
var dTips = new Hashtable()
return DialogMultiMaskedInput(sTitle, aNames, aValues, aMasks, aTypes, iFocus, dTips)
} // DialogMultiMaskedInput method

static function DialogMultiMaskedInput(sTitle: String, aNames, aValues, aMasks, aTypes): String[] {
var iFocus = 0
var dTips = new Hashtable()
return DialogMultiMaskedInput(sTitle, aNames, aValues, aMasks, aTypes, iFocus, dTips)
} // DialogMultiMaskedInput method

static function DialogMultiMaskedInput(sTitle: String, aNames, aValues, aMasks, aTypes, iFocus: Int32): String[] {
var dTips = new Hashtable()
var aTypes = []
return DialogMultiMaskedInput(sTitle, aNames, aValues, aMasks, aTypes, iFocus, dTips)
} // DialogMultiMaskedInput method

static function DialogMultiMaskedInput(sTitle: String, aNames, aValues, aMasks, aTypes, iFocus: Int32, dTips: Hashtable): String[] {
// Input multiple values

if (!sTitle) var sTitle = 'Multi Input'
if (!aNames) var aNames = []
if (!aValues) var aValues = Jax.JsInitArray('', aNames.length)
if (!aMasks) var aMasks = Jax.JsInitArray('', aNames.length)
if (!aTypes) var aTypes = Jax.JsInitArray('', aNames.length)
if (!iFocus) var iFocus = 0
if (!dTips) var dTips = new Hashtable()
// for (var sKey in dTips) Lbc.DialogShow(sKey, dTips[sKey])
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogMultiMaskedInput', dTips)
for (var i = 0; i < aNames.length; i++){
var sName = aNames[i]
var sValue = aValues[i]
var sMask = aMasks[i]
var tType = aTypes[i]
var txt:MaskedTextBox = dlg.AddMaskedInputBox(sName, sValue, sMask, tType)
if (aNames.length - i > 1) dlg.AddBand()
}
dlg.CompleteDialog([], iFocus)

var aReturn = dlg.Result
dlg.Dispose()
return aReturn
} // DialogMultiMaskedInput method

static function DialogMultiPick(sTitle: String, sLabel: String, aNames): Object[] {
var aValues = aNames
var aSelect = Jax.JsInitArray(false, aNames.length)
var bSort = false
var iIndex = 0
var dTips = new Hashtable()
return DialogMultiPick(sTitle, sLabel, aNames, aValues, aSelect, bSort, iIndex, dTips)
} // DialogMultiPick method

static function DialogMultiPick(sTitle: String, sLabel: String, aNames, aValues, aSelect, bSort: Boolean, iIndex: Int32): Object[] {
var dTips = new Hashtable()
return DialogMultiPick(sTitle, sLabel, aNames, aValues, aSelect, bSort, iIndex, dTips)
} // DialogMultiPick method

static function DialogMultiPick(sTitle: String, sLabel: String, aNames, aValues, aSelect, bSort: Boolean, iIndex: Int32, dTips: Hashtable): Object[] {
// Pick multiple values

if (!sTitle) var sTitle = 'Multi Pick'
if (!sLabel) var sLabel = ''
if (!aNames) var aNames = []
if (!aValues) var aValues = aNames
if (!aSelect) var aSelect = Jax.JsInitArray(false, aNames.length)
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogMultiPick', dTips)
dlg.ItemTips = aValues
var lst:ListBox = dlg.AddMultiPickBox(sLabel, aNames, aSelect, bSort, iIndex, sTip)
if (bSort) lst.Sorted = true
if (iIndex >= 0 && lst.Items.Count) lst.SelectedIndex = iIndex
dlg.CompleteDialog([])

var aResults = dlg.Result
if (!aResults) aResults = []
dlg.Dispose()
var aReturn = []
for (var i = 0; i < aResults.length; i++) {
var iIndex = aResults[i]
var oValue = aValues[iIndex]
aReturn.push(oValue)
}
return aReturn
} // DialogMultiPick method

static function DialogNumberPicker(sTitle: String, sText: String): Int32 {
var iValue = null
var iMinValue = null
var iMaxValue = null
var dTips = new Hashtable()
return DialogNumberPicker(sTitle, sText, iValue, iMinValue, iMaxValue, dTips)
} // DialogNumberPicker method

static function DialogNumberPicker(sTitle: String, sText: String, iValue: Int32, iMinValue: Int32, iMaxValue: Int32): Int32 {
var dTips = new Hashtable()
return DialogNumberPicker(sTitle, sText, iValue, iMinValue, iMaxValue, dTips)
} // DialogNumberPicker method

static function DialogNumberPicker(sTitle: String, sText: String, iValue: Int32, iMinValue: Int32, iMaxValue: Int32, dTips: Hashtable): Int32 {
// Pick a numeric value

if (!sTitle) var sTitle = 'NumericUpDown Pick'
if (!sText) var sText = ''
if (!iValue) var iValue = null
if (!iMinValue) var iMinValue = null
if (!iMaxValue) var iMaxValue = null
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogNumberPicker', dTips)
var nup:NumericUpDown = dlg.AddNumericUpDown(sText, iValue, iMinValue, iMaxValue, sTip)
dlg.CompleteDialog([])

var dtReturn = dlg.Result
dlg.Dispose()
return dtReturn
} // DialogNumberPicker method

static function DialogOpenFile(sTitle: String): String {
var sPath = ''
return DialogOpenFile(sTitle, sPath)
} // DialogOpenFile method

static function DialogOpenFile(sTitle: String, sPath: String) : String{
// Get a file path to open

var sReturn = ''
var dlg = new OpenFileDialog()
if (sTitle) dlg.Title = sTitle
var sDir = ''
if (Directory.Exists(sPath)) sDir = sPath
else {
if (File.Exists(sPath)) dlg.FileName = sPath
if (sPath) sDir = Path.GetDirectoryName(sPath)
if (!Directory.Exists(sDir)) sDir = Directory.GetCurrentDirectory()
}
dlg.InitialDirectory = sDir

dlg.Filter = 'All files (*.*)|*.*'
dlg.FilterIndex = 1
dlg.ValidateNames = true
dlg.CheckPathExists = true

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

static function DialogOpenFolder(sTitle: String): String {
var sFolder = ''
var dTips = new Hashtable()
return DialogOpenFolder(sTitle, sFolder, dTips)
} // DialogOpenFolder method

static function DialogOpenFolder(sTitle: String, sFolder: String): String {
var dTips = new Hashtable()
return DialogOpenFolder(sTitle, sFolder, dTips)
} // DialogOpenFolder method

static function DialogOpenFolder(sTitle: String, sFolder: String, dTips: Hashtable): String {
// Get a folder path to open

if (!sTitle) var sTitle = 'Open Folder'
if (!sFolder) var sFolter = ''
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogOpenFolder', dTips)
var sLabel = 'Name'
var txt:TextBox = dlg.AddInputBox(sLabel, sFolder, sTip)
txt.AutoCompleteMode = AutoCompleteMode.SuggestAppend
txt.AutoCompleteSource = AutoCompleteSource.FileSystemDirectories

var btn = dlg.AddButton('Browse')
dlg.CompleteDialog([])

var sReturn = dlg.Result
dlg.Dispose()
return sReturn
} // DialogOpenFolder method

static function DialogPick(sTitle: String, sLabel: String, aNames): Object {
var aValues = aNames
var bSort = false
var iIndex = 0
var dTips = new Hashtable()
return DialogPick(sTitle, sLabel, aNames, aValues, bSort, iIndex, dTips)
} // DialogPick method

static function DialogPick(sTitle: String, sLabel: String, aNames, aValues): Object {
var bSort = false
return DialogPick(sTitle, sLabel, aNames, aValues, bSort)
} // DialogPick method

static function DialogPick(sTitle: String, sLabel: String, aNames, aValues, bSort): Object {
var iIndex = 0
return DialogPick(sTitle, sLabel, aNames, aValues, bSort, iIndex)
} // DialogPick method

static function DialogPick(sTitle: String, sLabel: String, aNames, aValues, bSort: Boolean, iIndex: Int32): Object {
var dTips = new Hashtable()
return DialogPick(sTitle, sLabel, aNames, aValues, bSort, iIndex, dTips)
} // DialogPick method

static function DialogPick(sTitle: String, sLabel: String, aNames, aValues, bSort: Boolean, iIndex: Int32, dTips: Hashtable): Object {
// Pick a value

if (!sTitle) var sTitle = 'Pick'
if (!aNames) var aNames = []
if (!aValues) var aValues = aNames
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogPick', dTips)
dlg.ItemTips = aValues
var lst:ListBox = dlg.AddPickBox(sLabel, aNames, bSort, iIndex, sTip)
if (bSort) lst.Sorted = true
if (iIndex >= 0 && lst.Items.Count) lst.SelectedIndex = iIndex
dlg.CompleteDialog([])

var iIndex = dlg.Result
dlg.Dispose()
if (iIndex >= 0) return aValues[iIndex]
else return null
} // DialogPick method

static function DialogPickAndChoose(sTitle: String, sLabel: String, aNames, aValues, bSort: Boolean, iIndex: Int32, aButtons): Object[] {
var iFocus = 0
var dTips = new Hashtable()
return DialogPickAndChoose(sTitle, sLabel, aNames, aValues, bSort, iIndex, aButtons, iFocus, dTips)
} // DialogPickAndChoose method

static function DialogPickAndChoose(sTitle: String, sLabel: String, aNames, aValues, bSort: Boolean, iIndex: Int32, aButtons, iFocus: Int32): Object[] {
var dTips = new Hashtable()
return DialogPickAndChoose(sTitle, sLabel, aNames, aValues, bSort, iIndex, aButtons, iFocus, dTips)
} // DialogPickAndChoose method

static function DialogPickAndChoose(sTitle: String, sLabel: String, aNames, aValues, bSort: Boolean, iIndex: Int32, aButtons, iFocus: Int32, dTips: Hashtable): Object[] {
// Pick a value and choose a button

if (!sTitle) var sTitle = 'Pick and Choose'
if (!sLabel) var sLabel = ''
if (!aNames) var aNames = []
if (!aValues) var aValues = aNames
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!aButtons) var aButtons = []
if (!iFocus) var iFocus = 0
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogPickAndChoose', dTips)
dlg.ItemTips = aValues
dlg.AddPickBox(sLabel, aNames, bSort, iIndex, sTip)
aButtons.push('Cancel')
dlg.CompleteDialog(aButtons, iFocus)

var aResults = dlg.Result
dlg.Dispose()
var aReturn = []
if (aResults.length) {
var oValue = null
var iIndex = aResults[0]
if (iIndex >= 0) oValue = aValues[iIndex]
aReturn.push(oValue)
var sValue = aResults[1]
aReturn.push(sValue)
}
return aReturn
} // DialogPickAndChoose method

static function DialogPickInputAndChoose(sTitle: String, sLabel: String, aNames, aValues, bSort: Boolean, iIndex: Int32, sName: String, sValue: String, aButtons): Object[] {
var iFocus = 0
var dTips = new Hashtable()
return DialogPickInputAndChoose(sTitle, sLabel, aNames, aValues, bSort, iIndex, sName, sValue, aButtons, iFocus, dTips)
} // DialogPickInputAndChoose method

static function DialogPickInputAndChoose(sTitle: String, sLabel: String, aNames, aValues, bSort: Boolean, iIndex: Int32, sName: String, sValue: String, aButtons, iFocus: Int32): Object[] {
var dTips = new Hashtable()
return DialogPickInputAndChoose(sTitle, sLabel, aNames, aValues, bSort, iIndex, sName, sValue, aButtons, iFocus, dTips)
} // DialogPickInputAndChoose method

static function DialogPickInputAndChoose(sTitle: String, sLabel: String, aNames, aValues, bSort: Boolean, iIndex: Int32, sName: String, sValue: String, aButtons, iFocus: Int32, dTips: Hashtable): Object[] {
// Pick a value, input a value, and choose a button

if (!sTitle) var sTitle = 'Pick, Input, and Choose'
if (!sLabel) var sLabel = ''
if (!aNames) var aNames = []
if (!aValues) var aValues = aNames
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!sName) var sName = ''
if (!sValue) var sValue = ''
if (!aButtons) var aButtons = 0
if (!iFocus) var iFocus = 0
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogPickInputAndChoose', dTips)
dlg.ItemTips = aValues
dlg.AddPickBox(sLabel, aNames, bSort, iIndex, sTip)
dlg.AddBand()
dlg.AddInputBox(sName, sValue, sTip)
aButtons.push('Cancel')
dlg.CompleteDialog(aButtons, iFocus)

var aResults = dlg.Result
dlg.Dispose()
var aReturn = []
var oValue = null
var iIndex = aResults[0]
if (iIndex >= 0) oValue = aValues[iIndex]
aReturn.push(oValue)
var sValue = aResults[1]
aReturn.push(sValue)
var sButton = aResults[2]
aReturn.push(sButton)
return aReturn
} // DialogPickInputAndChoose method

static function DialogSaveFile(sTitle: String): String {
var sPath = ''
return DialogSaveFile(sTitle, sPath)
} // DialogSaveFile method

static function DialogSaveFile(sTitle: String, sPath: String): String {
// Get a file path to save

var sReturn = ''
var sDir = ''
var dlg = new SaveFileDialog()
if (sTitle) dlg.Title = sTitle
if (Directory.Exists(sPath)) sDir = sPath
else {
if (File.Exists(sPath)) dlg.FileName = sPath
if (sPath) sDir = Path.GetDirectoryName(sPath)
}

if (Directory.Exists(sDir)) dlg.InitialDirectory = sDir

dlg.Filter = 'All files (*.*)|*.*'
dlg.FilterIndex = 1
dlg.CheckPathExists = true
dlg.SupportMultiDottedExtensions = true
dlg.CreatePrompt = false
dlg.ValidateNames = true
dlg.AddExtension = true
dlg.DefaultExt = 'txt'

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

static function DialogShow(oTitle) {
var oMessage = ''
return DialogShow(oTitle, oMessage)
} // DialogShow method

static function DialogShow(oTitle, oMessage) {
// Show two values in the title and message of a message box

var sTitle = oTitle.ToString()
var sMessage = oMessage.ToString()
MessageBox.Show(sMessage, sTitle)
} //DialogShow method

static function DialogTimePicker(sTitle: String): DateTime {
var sLabel = ''
var dtValue = null
var dtMinValue = null
var dtMaxValue = null
var dTips = new Hashtable()
return DialogTimePicker(sTitle, sLabel, dtValue, dtMinValue, dtMaxValue, dTips)
} // DialogTimePicker method

static function DialogTimePicker(sTitle: String, sLabel: String, dtValue, dtMinValue, dtMaxValue) {
var dTips = new Hashtable()
return DialogTimePicker(sTitle, sLabel, dtValue, dtMinValue, dtMaxValue, dTips)
} // DialogTimePicker method

static function DialogTimePicker(sTitle: String, sLabel: String, dtValue, dtMinValue, dtMaxValue, dTips: Hashtable) {
// Pick a time value

if (!sTitle) var sTitle = 'DateTime Pick'
if (!sLabel) var sLabel = ''
if (!dtValue) var dtValue = null
if (!dtMinValue) var dtMinValue = null
if (!dtMaxValue) var dtMaxValue = null
if (!dTips) var dTips = new Hashtable()
var sTip = ''

var dlg = new LbcForm(sTitle, 'this.HandleDialogTimePicker', dTips)
var dtp:DateTimePicker = dlg.AddTimePickerBox(sLabel, dtValue, dtMinValue, dtMaxValue, sTip)
dlg.CompleteDialog([])

var dtReturn = dlg.Result
dlg.Dispose()
return dtReturn
} // DialogTimePicker method

static function ExecuteScript(sCode: String) {
return eval(sCode, 'unsafe')
} // ExecuteScript method

static function ExecuteScript(sCode: String, App) {
return eval(sCode, 'unsafe')
} // ExecuteScript method

static function ExecuteScript(sCode: String, App, dParams) {
return eval(sCode, 'unsafe')
} // ExecuteScript method

static function GetClass(ctl) {
// Get the class of a control

var sType = ctl.GetType().ToString()
var aParts = sType.split('.')
var sClass = aParts.slice(-1)
return sClass
} // GetClass method

static function GetAlias(o): String {
/*
var ctl:Control = o
var sName: String = ctl.Name
var frm: LbcForm = ctl.FindForm()
var sAlias: String = frm.Aliases[sName]
if (!sAlias) sAlias = ''
return sAlias
*/

var sName = Lbc.GetName(o)
var sLabel = ''
var iIndex = sName.IndexOf("_")
if (iIndex >= 0) sLabel = sName.Substring(iIndex + 1).Replace("_", " ")
return sLabel
} // GetAlias method

static function GetName(o): String {
var sName = o.Name
if (!sName) sName = ''
return sName
} // GetName method

static function GetText(o): String {
var sText = o.Text
if (!sText) sText = ''
return sText
} // GetText method

static function GetTip(o): String {
var ctl:Control = o
var sName: String = ctl.Name
var frm: LbcForm = ctl.FindForm()
var sTip: String = frm.FocusTips[sName]
if (Jax.JsIsNone(sTip)) sTip = ''
return sTip
} // GetTip method



static function HandleEvent(oArgs) {
oArgs.Handled = true
} // HandleEvent method

static function Init(sCodeFile: String, sImportFile: String, sExportFile: String) {
// Initialize values for code, import, and export files

var aArgs = Environment.GetCommandLineArgs()
if (sCodeFile) Lbc.CodeFile = sCodeFile
else if (aArgs.Length > 1 && File.Exists(aArgs[1])) Lbc.CodeFile = aArgs[1]

if (sImportFile) Lbc.ImportFile = sImportFile
else if (aArgs.Length > 2) Lbc.ImportFile = aArgs[2]

if (sExportFile) Lbc.ExportFile = sExportFile
else if (aArgs.Length > 3) Lbc.ExportFile = aArgs[3]
} // Init method

static function MakeAccessibleName(sLabel: String) {
// Make an accessible control name

var sName = sLabel.Replace('&', '')
sName = sName.Replace(':', '')
sName = sName.Replace('...', '')
sName = sName.Trim()
return sName
} // MakeAccessibleName method

static function MakeCaption(sText: String) {
// Make a control caption

var sReturn = sText
if (sText.IndexOf('&') == -1) sReturn = '&' + sText
return sReturn
} // MakeCaption method

static function MakeFriendlyKeyName(sKey: String) {
// Make a key string more friendly

if (sKey.Contains('+OemQuotes')) sKey = sKey.Replace('+OemQuotes', '+Apostrophe')
if (sKey.Contains('+Back')) sKey = sKey.Replace('+Back', '+Backspace')
if (sKey.Contains('+Oem5')) sKey = sKey.Replace('+Oem5', '+Backslash')
if (sKey.Contains('+Oemplus')) sKey = sKey.Replace('+Oemplus', '+Equals')
if (sKey.Contains('+OemMinus')) sKey = sKey.Replace('+OemMinus', '+Dash')
if (sKey.Contains('+OemSemicolon')) sKey = sKey.Replace('+OemSemicolon', '+Semicolon')
if (sKey.Contains('+D6')) sKey = sKey.Replace('+D6', '+Caret')
if (sKey.Contains('+D0')) sKey = sKey.Replace('+D0', '+0')
if (sKey.Contains('+OemQuestion')) sKey = sKey.Replace('+OemQuestion', '+Slash')
if (sKey.Contains('+OemOpenBrackets')) sKey = sKey.Replace('+OemOpenBrackets', '+LeftBracket')
if (sKey.Contains('+OemCloseBrackets')) sKey = sKey.Replace('+OemCloseBrackets', '+RightBracket')
if (sKey.Contains('+Oemcomma')) sKey = sKey.Replace('+Oemcomma', '+Comma')
if (sKey.Contains('+OemPeriod')) sKey = sKey.Replace('+OemPeriod', '+Period')
return sKey
} // MakeFriendlyKeyName method

static function MakeLabel(sText: String) {
// Make a control label

var sReturn = MakeCaption(sText)
if (sReturn.indexOf(':') == -1) sReturn += ':'
return sReturn
} // MakeLabel method

static function MakeName(ctl, sLabel: String) {
// Make a control name

var sType = Lbc.GetClass(ctl)
var sName = MakeAccessibleName(sLabel)
sName = sName.Replace(' ', '_')
sName = sType + '_' + sName
return sName
} // MakeName method

static function StringToKey(sKey:String):Keys {
// Convert a string to a Keys object

return TypeDescriptor.GetConverter(Keys).ConvertFromString(sKey)
} // String2Key method

static function ToStringArray(oCollection: ICollection  ): String[] {
// Convert a collection to an array

var iCount = oCollection.Count
// var aReturn: String[] = new String[iCount]
// var aReturn = Array.CreateInstance(''.GetType(), iCount)
// var aReturn = Array.CreateInstance(typeof(String), iCount)
var aReturn = []
// for (var i = 0; i < iCount; i++) aReturn.push(oCollection[i])
for (var s: String in oCollection) aReturn.push(s)
// oCollection.CopyTo(aReturn, 0)
return aReturn
} // ToStringArray method
} // Lbc class

class LbcForm extends Form {
var CancelButtonClicked: Boolean = false
var SuppressedCommandNames: String[] = ['Extra Speech', 'Extra Keys']
var SpeechOnlyCommandNames: String[] = ['Status']
var StatusOnlyCommandNames: String[] = ['OK', 'Cancel']
var LastAcceptButton: Button = null
var LastStatus: String = ''
var ExtraKeys: Boolean = true
var KeyDescriber: Boolean = false
var IsDialog: Boolean = false
var MainPanel = null
var Widgets:OrderedDictionary = new OrderedDictionary()
var Aliases :Hashtable = new Hashtable()
var FocusTips :Hashtable = new Hashtable()
// var FocusTips = new Hashtable()
var ItemTips = []
var Handler = 'OnEvent'
var Result = null
var LastFocusJump = ''

function ControlMenu() {
var aNames = []
var aValues = []
var aWidgets = this.GetWidgets()
for (var i = 0; i < aWidgets.length; i++ ) {
var wgt = aWidgets[i]
var sName = wgt.Name
if (!wgt.CanFocus || Jax.JsIsNone(sName) || sName.StartsWith('Label_') || sName.StartsWith('MenuItem_') || sName.StartsWith('StatusBar')) continue

var sText = this.Aliases[sName]
var sTip = this.FocusTips[sName]
if (!Jax.JsIsNone(sTip)) sText = sText + ' = ' + sTip
aNames.push(sText)
aValues.push(wgt)
} // for i
if (aNames.Length == 0) return this.AddMessage('No focusable controls found!')

wgt = Lbc.DialogPick('Control Menu', '', aNames, aValues)
if (Jax.JsIsNone(wgt)) return

wgt.Select()
} // ControlMenu method

function StartSelection() {
var txt: Object = this.GetFocusControl()
var sName: String = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

this.SetMessage('Start Selection')
var iIndex: Int32 = txt.SelectionStart + txt.SelectionLength
txt.Tag = iIndex
if (iIndex < txt.TextLength) this.SetMessage(txt.Text[iIndex])
} // StartSelection method

function CompleteSelection() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

this.SetMessage('Complete Selection')
var iStart: Int32 = txt.Tag
var iEnd: Int32 = txt.SelectionStart + txt.SelectionLength
var iLength: Int32 = iEnd - iStart
txt.Select(iStart, iLength)
this.SetMessage(Jax.StringPlural('character', txt.SelectionLength))
} // CompleteSelection method

function CopyAll() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

this.SetMessage('Copy All')
Clipboard.SetText(txt.Text)
} // CopyAll method

function ReadAll() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

this.SetMessage('Read All')
this.SetMessage(txt.Text)
} // ReadAll method

function Copy() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

if (txt.SelectionLength > 0) txt.Copy()
else {
var iIndex: Int32 = txt.SelectionStart + txt.SelectionLength
var iRow: Int32 = txt.GetLineFromCharIndex(iIndex)
var iStart: Int32 = txt.GetFirstCharIndexFromLine(iRow)
var iEnd: Int32 = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
else iEnd --
var iLength: Int32 = iEnd - iStart
var sText: String = txt.Text.Substring(iStart, iLength)
Clipboard.SetText(sText)
} // if SelectionLength
} // Copy method

function CopyAppend() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

var sText: String = Clipboard.GetText()
if (sText.Length > 0 && !sText.EndsWith('\n')) sText = sText + '\r\n'
if (txt.SelectionLength > 0) sText = sText + txt.SelectedText
else {
var iIndex: Int32 = txt.SelectionStart + txt.SelectionLength
var iRow: Int32 = txt.GetLineFromCharIndex(iIndex)
var iStart: Int32 = txt.GetFirstCharIndexFromLine(iRow)
var iEnd: Int32 = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
else iEnd --
var iLength: Int32 = iEnd - iStart
sText = sText + txt.Text.Substring(iStart, iLength)
}
Clipboard.SetText(sText)
} // CopyAppend method

function Cut() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

var iIndex: Int32 = txt.SelectionStart + txt.SelectionLength
var iRow: Int32 = txt.GetLineFromCharIndex(iIndex)
var iStart: Int32 = txt.GetFirstCharIndexFromLine(iRow)
var iEnd: Int32 = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
// else iEnd --
var iLength: Int32 = iEnd - iStart
if (txt.SelectionLength == 0) txt.Select(iStart, iLength)
txt.Cut()

txt.SelectionStart = iStart
txt.SelectionLength = 0
iIndex = txt.SelectionStart + txt.SelectionLength
iRow = txt.GetLineFromCharIndex(iIndex)
iStart = txt.GetFirstCharIndexFromLine(iRow)
iEnd = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
iLength = iEnd - iStart
var sText = txt.Text.Substring(iStart, iLength)
Acc.Say(sText)
} // Cut method

function CutAppend() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

var sText: String = Clipboard.GetText()
if (sText.Length > 0 && !sText.EndsWith('\n')) sText = sText + '\r\n'

var iIndex: Int32 = txt.SelectionStart + txt.SelectionLength
var iRow: Int32 = txt.GetLineFromCharIndex(iIndex)
var iStart: Int32 = txt.GetFirstCharIndexFromLine(iRow)
var iEnd: Int32 = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
// else iEnd --
var iLength: Int32 = iEnd - iStart
if (txt.SelectionLength == 0) txt.Select(iStart, iLength)

txt.Cut()
sText = sText + Clipboard.GetText()
Clipboard.SetText(sText)

txt.SelectionStart = iStart
txt.SelectionLength = 0
iIndex = txt.SelectionStart + txt.SelectionLength
iRow = txt.GetLineFromCharIndex(iIndex)
iStart = txt.GetFirstCharIndexFromLine(iRow)
iEnd = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
iLength = iEnd - iStart
var sText = txt.Text.Substring(iStart, iLength)
Acc.Say(sText)
} // CutAppend method

function DeleteLine() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

var iIndex: Int32 = txt.SelectionStart + txt.SelectionLength
var iRow: Int32 = txt.GetLineFromCharIndex(iIndex)
var iStart: Int32 = txt.GetFirstCharIndexFromLine(iRow)
var iEnd: Int32 = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
var iLength: Int32 = iEnd - iStart
var sText: String = txt.Text.Remove(iStart, iLength)
txt.Text = sText

txt.SelectionStart = iStart
txt.SelectionLength = 0
iIndex = txt.SelectionStart + txt.SelectionLength
iRow = txt.GetLineFromCharIndex(iIndex)
iStart = txt.GetFirstCharIndexFromLine(iRow)
iEnd = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
iLength = iEnd - iStart
sText = txt.Text.Substring(iStart, iLength)
Acc.Say(sText)
} // DeleteLine method

function Documentation() {
Process.Start(LbcMdiApp.Instance.HelpFile)
} // Documentation method

function ManualOptions() {
Process.Start(LbcMdiApp.Instance.IniFile)
} // ManualOptions method

function AboutBox() {
var sText = ''
/*
sText += Application.ProductName + '\n'
var sVersion = Application.ProductVersion
var aVersion = sVersion.split('.')
sVersion = aVersion[0] + '.' + aVersion[1]
sText += 'Version ' + sVersion + '\n'
sText += 'Executable ' + Application.ExecutablePath + '\n'
sText += 'By ' + Application.CompanyName + '\n'
// sText += Application.CurrentCulture + '\n'
// sText += Application.CurrentInputLanguage + '\n'
*/

var oInfo: FileVersionInfo = FileVersionInfo.GetVersionInfo(Application.ExecutablePath)
sText += oInfo.ProductName + '\n'
sText += 'Version ' + oInfo.ProductMajorPart + '.' + oInfo.ProductMinorPart + '\n'
if (oInfo.Comments) sText += oInfo.Comments + '\n'
sText += '\n'
if (oInfo.CompanyName) sText += 'From ' + oInfo.CompanyName + '\n'
if (oInfo.LegalCopyright) sText += oInfo.LegalCopyright + '\n'
if (oInfo.LegalTrademarks) sText += oInfo.LegalTrademarks + '\n'
Lbc.DialogShow('About', sText)
} // AboutBox method

function AddBackgroundWorker() {
// Add a BackgroundWorker

var bkw:BackgroundWorker = new BackgroundWorker()
bkw.WorkerReportsProgress = true
bkw.WorkerSupportsCancellation = true
var sName = 'BackgroundWorker_'
// Does not have this property
// bkw.Name = sName
bkw.add_DoWork(Delegate.CreateDelegate(DoWorkEventHandler, this, 'HandleDoWork'))
bkw.add_ProgressChanged(Delegate.CreateDelegate(ProgressChangedEventHandler, this, 'HandleProgressChanged'))
bkw.add_RunWorkerCompleted(Delegate.CreateDelegate(RunWorkerCompletedEventHandler, this, 'HandleRunWorkerCompleted'))
return bkw
} // AddBackgroundWorker method

function AddBand() {
// Start a new band of controls

var flp = CreateHorizontalPanel()
this.MainPanel.Controls.Add(flp)
return flp
} // AddBand method

function AddButton(sText: String):Button {
var sTip = ''
return AddButton(sText, sTip)
} // AddButton method

function AddButton(sText: String, sTip: String):Button {
// Add a button

var btn:Button = new Button()
if (sText == 'OK') this.AcceptButton = btn
else if (sText == 'Cancel' || sText == 'Close') this.CancelButton = btn
else var sText = Lbc.MakeCaption(sText)
btn.Text = sText
btn.AccessibleName = Lbc.MakeAccessibleName(sText)
var sName = Lbc.MakeName(btn, sText)
btn.Name = sName
this.Widgets[sName] = btn
this.Aliases[sName] = btn.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
btn.add_Click(Delegate.CreateDelegate(EventHandler, this, 'HandleClick'))
// btn.add_Click(new EventHandler(this.HandleClick))
btn.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(btn)
return btn
} // AddButton method

function AddButtonBand(aButtons) {
// Add a centered band of buttons

var aReturn = []
// if (!aButtons) var aButtons = ['OK', 'Cancel']
if (aButtons.length == 0) var aButtons = ['OK', 'Cancel']
var flp = AddBand()
flp.Anchor = AnchorStyles.None
for (var i = 0; i < aButtons.length; i++) {
var sButton = aButtons[i]
var btn = AddButton(sButton)
// if (i == iFocus) btn.Select()
aReturn.push(btn)
}
return aReturn
} // AddButtonBand method

function AddCheckBox(sText: String):CheckBox {
var bState = false
var sTip = ''
return AddCheckBox(sText, bState, sTip)
} // AddCheckBox method

function AddCheckBox(sText: String, bState: Boolean):CheckBox {
var sTip = ''
return AddCheckBox(sText, bState, sTip)

} // AddCheckBox method

function AddCheckBox(sText: String, bState: Boolean, sTip: String):CheckBox {
// Add a checkbox

if (!sText) var sText = ''
if (!bState) var bState = false
if (!sTip) var sTip = ''

var chk:CheckBox = new CheckBox()
chk.Checked = bState
var sText = Lbc.MakeCaption(sText)
chk.Text = sText
chk.AccessibleName = Lbc.MakeAccessibleName(sText)
var sName = Lbc.MakeName(chk, sText)
chk.Name = sName
this.Widgets[sName] = chk
this.Aliases[sName] = chk.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
chk.add_Click(Delegate.CreateDelegate(EventHandler, this, 'HandleClick'))
chk.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(chk)
return chk
} // AddCheckBox method

function AddCheckedListBox(): CheckedListBox {
var aItems = []
var aSelect = []
var bSort = false
var iIndex = 0
var sTip = ''
return AddCheckedListBox(aItems, aSelect, bSort, iIndex, sTip)
} // AddCheckedListBox method

function AddCheckedListBox(aItems, aSelect, bSort: Boolean, iIndex: Int32):CheckedListBox {
var sTip = ''
return AddCheckedListBox(aItems, aSelect, bSort, iIndex, sTip)
} // AddCheckedListBox method

function AddCheckedListBox(aItems, aSelect, bSort: Boolean, iIndex: Int32, sTip: String):CheckedListBox {
// Add a checked listbox

if (!aItems) var aItems = []
if (!aSelect) var aSelect = Jax.JsInitArray(false, aItems.length)
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lst:CheckedListBox = new CheckedListBox()
// lst.SelectionMode = SelectionMode.MultiSimple
for (var i = 0; i < aItems.length; i++) {
lst.Items.Add(aItems[i])
Support.SetItemData(lst, i, i)
var bState = aSelect[i]
if (!bState) bState = false
lst.SetItemChecked(i, bState)
}

lst.Sorted = bSort
if (iIndex >= 0 && lst.Items.Count) lst.SelectedIndex = iIndex

var sName = 'CheckedListBox_'
var lbl = CurrentControl()
// if (lbl) {
if (lbl != null) {
lst.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'CheckedListBox_')
}
lst.Name = sName
this.Widgets[sName] = lst
this.Aliases[sName] = lst.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
lst.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
lst.add_SelectedIndexChanged(Delegate.CreateDelegate(EventHandler, this, 'HandleSelectedIndexChanged'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(lst)
return lst
} // AddCheckedListBox method

function AddComboBox(): ComboBox {
var aItems = []
var bSort = false
var iIndex = 0
var sTip = ''
return AddComboBox(aItems, bSort, iIndex, sTip)
} // AddComboBox method

function AddComboBox(aItems, bSort: Boolean, iIndex: Int32):ComboBox {
var sTip = ''
return AddComboBox(aItems, bSort, iIndex, sTip)
} // AddComboBox method

function AddComboBox(aItems, bSort: Boolean, iIndex: Int32, sTip: String):ComboBox {
// Add a combobox

if (!aItems) var aItems = []
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lst:ComboBox = new ComboBox()
for (var i = 0; i < aItems.length; i++) {
lst.Items.Add(aItems[i])
Support.SetItemData(lst, i, i)
}
lst.Sorted = bSort
if (iIndex >= 0 && lst.Items.Count) lst.SelectedIndex = iIndex

var sName = 'ComboBox_'
var lbl = CurrentControl()
// if (lbl) {
if (lbl != null) {
lst.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'ComboBox_')
}
lst.Name = sName
this.Widgets[sName] = lst
this.Aliases[sName] = lst.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
lst.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
lst.add_SelectedIndexChanged(Delegate.CreateDelegate(EventHandler, this, 'HandleSelectedIndexChanged'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(lst)
return lst
} // AddComboBox method

function AddComboPickBox(sLabel: String): ComboBox {
var aItems = []
var bSort = false
var iIndex = 0
var sTip = ''
return AddComboPickBox(sLabel, aItems, bSort, iIndex, sTip)
} // AddComboPickBox methodd

function AddComboPickBox(sLabel: String, aItems, bSort: Boolean, iIndex: Int32):ComboBox {
var sTip = ''
return AddComboPickBox(sLabel, aItems, bSort, iIndex, sTip)
} // AddComboPickBox method

function AddComboPickBox(sLabel: String, aItems, bSort: Boolean, iIndex: Int32, sTip: String):ComboBox {
// Add a labeled combobox

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var lst:ComboBox = AddComboBox(aItems, bSort, iIndex, sTip)
return lst
} // AddComboPickBox method

function AddDatePicker(): DateTimePicker {
var dtValue = null
var dtMinValue = null
var dtMaxValue = null
var sTip = ''
return AddDatePicker(dtValue, dtMinValue, dtMaxValue, sTip)
} // AddDatePicker method

function AddDatePicker(dtValue, dtMinValue, dtMaxValue):DateTimePicker {
var sTip = ''
return AddDatePicker(dtValue, dtMinValue, dtMaxValue, sTip)
} // AddDatePicker method

function AddDatePicker(dtValue, dtMinValue, dtMaxValue, sTip: String):DateTimePicker {
// Add a date picker

if (!dtValue) var dtValue = null
if (!dtMinValue) var dtMinValue = null
if (!dtMaxValue) var dtMaxValue = null
if (!sTip) var sTip = ''

var dtp: DateTimePicker = new DateTimePicker()
// dtp.MinDate = new DateTime(1985, 6, 20)
// dtp.MaxDate = DateTime.Today
if (dtValue) dtp.Value = dtValue
if (dtMinValue) dtp.MinDate = dtMinValue
if (dtMaxValue) dtp.MaxDate = dtMaxValue
// dtp.Format = DateTimePickerFormat.Custom
// dtp.CustomFormat = "MMMM dd, yyyy - dddd"
// dtp.Format = DateTimePickerFormat.Short
dtp.Format = DateTimePickerFormat.Long

dtp.ShowCheckBox = false
dtp.ShowUpDown = true
var sName = 'DatePicker_'
var lbl = CurrentControl()
if (lbl != null) {
dtp.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'DatePicker_')
}
dtp.Name = sName
this.Widgets[sName] = dtp
this.Aliases[sName] = dtp.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
dtp.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(dtp)
return dtp
} // AddDatePicker method

function AddDatePickerBox(sLabel: String): DateTimePicker {
var dtValue = null
var dtMinValue = null
var dtMaxValue = null
var sTip = ''
return AddDatePickerBox(sLabel, dtValue, dtMinValue, dtMaxValue, sTip)
} // AddDatePickerBox

function AddDatePickerBox(sLabel: String, dtValue, dtMinValue, dtMaxValue):DateTimePicker {
var sTip = ''
return AddDatePickerBox(sLabel, dtValue, dtMinValue, dtMaxValue, sTip)

} // AddDatePickerBox

function AddDatePickerBox(sLabel: String, dtValue, dtMinValue, dtMaxValue, sTip: String):DateTimePicker {
// Add a labeled date picker

if (!sLabel) var sLabel = ''
if (!dtValue) var dtValue = null
if (!dtMinValue) var dtMinValue = null
if (!dtMaxValue) var dtMaxValue = null
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var dtp:DateTimePicker = AddDatePicker(dtValue, dtMinValue, dtMaxValue, sTip)
return dtp
} // AddDatePickerBox method

function AddInputBox(sLabel: String): TextBox {
var sText = ''
var sTip = ''
return AddInputBox(sLabel, sText, sTip)
} // AddInputBox method

function AddInputBox(sLabel: String, sText: String):TextBox {
var sTip = ''
return AddInputBox(sLabel, sText, sTip)

} // AddInputBox method

function AddInputBox(sLabel: String, sText: String, sTip: String):TextBox {
// Add a labeled TextBox

if (!sLabel) var sLabel = ''
if (!sText) var sText = ''
if (!sTip) var sTip = ''
var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var txt:TextBox = AddTextBox(sText, sTip)
if (lbl && lbl.Name.EndsWith('Password')) txt.UseSystemPasswordChar = true
// return [lbl, txt]
return txt
} // AddInputBox method

function AddLabel(sText: String):Label {
var sTip = ''
return AddLabel(sText, sTip)
} // AddLabel method

function AddLabel(sText: String, sTip: String):Label {
// Add a label

var lbl:Label = new Label()
var sText = Lbc.MakeLabel(sText)
lbl.Text = sText
lbl.AccessibleName = Lbc.MakeAccessibleName(sText)
var sName = Lbc.MakeName(lbl, sText)
lbl.Name = sName
this.Widgets[sName] = lbl
this.Aliases[sName] = lbl.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
this.MainPanel.Controls(CurrentBand()).Controls.Add(lbl)
return lbl
} // AddLabel method

function AddLabeledListView(sLabel: String):ListView {
var aHeaders = []
var aItems = []
var bSort = false
var bSingleSelect = false
var iIndex = 0
var sTip = ''
return AddLabeledListView(sLabel, aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddLabeledListView method

function AddLabeledListView(sLabel: String, aHeaders, aItems):ListView {
var bSort = false
var bSingleSelect = false
var iIndex = 0
var sTip = ''
return AddLabeledListView(sLabel, aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddLabeledListView method

function AddLabeledListView(sLabel: String, aHeaders, aItems, bSort: Boolean ):ListView {
var bSingleSelect = false
var iIndex = 0
var sTip = ''
return AddLabeledListView(sLabel, aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddLabeledListView method


function AddLabeledListView(sLabel: String, aHeaders, aItems, bSort: Boolean, bSingleSelect: Boolean):ListView {
var iIndex = 0
var sTip = ''
return AddLabeledListView(sLabel, aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddLabeledListView method


function AddLabeledListView(sLabel: String, aHeaders, aItems, bSort: Boolean, bSingleSelect: Boolean, iIndex: Int32):ListView {
var sTip = ''
return AddLabeledListView(sLabel, aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddLabeledListView method

function AddLabeledListView(sLabel: String, aHeaders, aItems, bSort: Boolean, bSingleSelect: Boolean, iIndex: Int32, sTip: String):ListView {
// Add a labeled ListView

if (!sLabel) var sLabel = ''
if (!aHeaders) var aHeaders = []
if (!aItems) var aItems = []
if (!bSort) var bSort = false
if (!bSingleSelect) var bSingleSelect = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var lv:ListView = AddListView(aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
return lv
} // AddLabeledListView method

function AddLabeledPictureBox(sLabel: String):PictureBox {
var sFile = ''
var sTip = ''
return AddLabeledPictureBox(sLabel, sFile, sTip)
} // AddLabeledPictureBox method

function AddLabeledPictureBox(sLabel: String, sFile: String):PictureBox {
var sTip = ''
return AddLabeledPictureBox(sLabel, sFile, sTip)

} // AddLabeledPictureBox method

function AddLabeledPictureBox(sLabel: String, sFile: String, sTip: String):PictureBox {
// Add a labeled PictureBox

if (!sLabel) var sLabel = ''
if (!sFile) var sFile = ''
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var pb:PictureBox = AddPictureBox(sFile, sTip)
return pb
} // AddLabeledPictureBox method

function AddLabeledTreeView(sLabel: String):TreeView {
var aNodes = []
var bSort = false
var iIndex = 0
var sTip = ''
return AddLabeledTreeView(sLabel, aNodes, bSort, iIndex, sTip)
} // AddLabeledTreeView method

function AddLabeledTreeView(sLabel: String, aNodes):TreeView {
var bSort = false
var iIndex = 0
var sTip = ''
return AddLabeledTreeView(sLabel, aNodes, bSort, iIndex, sTip)
} // AddLabeledTreeView method



function AddLabeledTreeView(sLabel: String, aNodes, bSort: Boolean):TreeView {
var iIndex = 0
var sTip = ''
return AddLabeledTreeView(sLabel, aNodes, bSort, iIndex, sTip)
} // AddLabeledTreeView method


function AddLabeledTreeView(sLabel: String, aNodes, bSort: Boolean, iIndex: Int32):TreeView {
var sTip = ''
return AddLabeledTreeView(sLabel, aNodes, bSort, iIndex, sTip)
} // AddLabeledTreeView method

function AddLabeledTreeView(sLabel: String, aNodes, bSort: Boolean, iIndex: Int32, sTip: String):TreeView {
// Add a labeled TreeView

if (!sLabel) var sLabel = ''
if (!aNodes) var aNodes = []
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var tv:TreeView = AddTreeView(aNodes, bSort, iIndex, sTip)
return tv
} // AddLabeledTreeView method

function AddListBox():ListBox {
var aItems = []
var bSort = false
var iIndex = 0
var sTip = ''
return AddListBox(aItems, bSort, iIndex, sTip)
} // AddListBox method

function AddListBox(aItems, bSort: Boolean, iIndex: Int32):ListBox {
var sTip = ''
return AddListBox(aItems, bSort, iIndex, sTip)
} // AddListBox method

function AddListBox(aItems, bSort: Boolean, iIndex: Int32, sTip: String):ListBox {
// Add a listbox

if (!aItems) var aItems = []
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lst:ListBox = new ListBox()
lst.SelectionMode = SelectionMode.One
for (var i = 0; i < aItems.length; i++) {
lst.Items.Add(aItems[i])
Support.SetItemData(lst, i, i)
}
lst.Sorted = bSort
if (iIndex >= 0 && lst.Items.Count) lst.SelectedIndex = iIndex

var sName = 'ListBox_'
var lbl = CurrentControl()
// if (lbl) {
if (lbl != null) {
lst.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'ListBox_')
}
lst.Name = sName
this.Widgets[sName] = lst
this.Aliases[sName] = lst.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
lst.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
lst.add_SelectedIndexChanged(Delegate.CreateDelegate(EventHandler, this, 'HandleSelectedIndexChanged'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(lst)
return lst
} // AddListBox method

function AddListView():ListView {
var aHeaders = []
var aItems = []
var bSort = false
var bSingleSelect = false
var iIndex = 0
var sTip = ''
return AddListView(aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddListView method

function AddListView(aHeaders, aItems):ListView {
var bSort = false
var bSingleSelect = false
var iIndex = 0
var sTip = ''
return AddListView(aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddListView method

function AddListView(aHeaders, aItems, bSort: Boolean):ListView {
var bSingleSelect = false
var iIndex = 0
var sTip = ''
return AddListView(aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddListView method

function AddListView(aHeaders, aItems, bSort, bSingleSelect):ListView {
var iIndex = 0
var sTip = ''
return AddListView(aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)
} // AddListView method

function AddListView(aHeaders, aItems, bSort: Boolean, bSingleSelect: Boolean, iIndex: Int32):ListView {
var sTip = ''
return AddListView(aHeaders, aItems, bSort, bSingleSelect, iIndex, sTip)

} // AddListView method

function AddListView(aHeaders, aItems, bSort, bSingleSelect, iIndex: Int32, sTip: String):ListView {
// Add a ListView

if (!aHeaders) var aHeaders = []
if (!aItems) var aItems = []
if (!bSort) var bSort = false
if (!bSingleSelect) var bSingleSelect = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lv:ListView = new ListView()
lv.View = View.Details
lv.HideSelection = false 
lv.HeaderStyle = ColumnHeaderStyle.Nonclickable
lv.GridLines = true
lv.FullRowSelect = true
if (bSort) lv.Sorting = SortOrder.Ascending
if (bSingleSelect) lv.MultiSelect = false

for (var i = 0; i < aHeaders.length; i++) {
var sHeader = aHeaders[i]
var lvHeader:ColumnHeader = new ColumnHeader()
lvHeader.Text = sHeader
lvHeader.TextAlign = HorizontalAlignment.Left
lv.Columns.Add(lvHeader)
}

for (var i = 0; i < aItems.length; i++) {
var aSubitems = aItems[i]
var lvItem:ListViewItem = new ListViewItem(aSubitems[0])
for (var j = 1; j < aSubitems.length; j++) {
lvItem.SubItems.Add(aSubitems[j])
}
lv.Items.Add(lvItem)
}
// if (iIndex >= 0 && lv.Items.Count) lv.Items[iIndex].Focused = true
if (iIndex >= 0 && lv.Items.Count) lv.Items[iIndex].Selected = true

var sName = 'ListView_'
var lbl = CurrentControl()
if (lbl != null) {
lv.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'ListView_')
}
lv.Name = sName
this.Widgets[sName] = lv
this.Aliases[sName] = lv.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
lv.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
lv.add_SelectedIndexChanged(Delegate.CreateDelegate(EventHandler, this, 'HandleSelectedIndexChanged'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(lv)
return lv
} // AddListView method

function AddMaskedInputBox(sLabel: String):MaskedTextBox {
var sText = ''
var sMask = ''
var tType = null
var sTip = ''
return AddMaskedInputBox(sLabel, sText, sMask, tType, sTip)
} // AddMaskedInputBox method

function AddMaskedInputBox(sLabel: String, sText: String, sMask: String):MaskedTextBox {
var tType = null
var sTip = ''
return AddMaskedInputBox(sLabel, sText, sMask, tType, sTip)
} // AddMaskedInputBox method

function AddMaskedInputBox(sLabel: String, sText: String, sMask: String, tType: Type):MaskedTextBox {
var sTip = ''
return AddMaskedInputBox(sLabel, sText, sMask, tType, sTip)
} // AddMaskedInputBox method

function AddMaskedInputBox(sLabel: String, sText: String, sMask: String, tType: Type, sTip: String):MaskedTextBox {
// Add a labeled MaskedTextBox

if (!sLabel) var sLabel = ''
if (!sText) var sText = ''
if (!sMask) var sMask = ''
if (!tType) var tType = null
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var txt:MaskedTextBox = AddMaskedTextBox(sText, sMask, tType, sTip)
return txt
} // AddMaskedInputBox method

function AddMaskedTextBox():MaskedTextBox {
var sText = ''
var sMask = ''
var tType = null
var sTip = ''
return AddMaskedTextBox(sText, sMask,tType, sTip)
} // AddMaskedTextBox method

function AddMaskedTextBox(sText: String, sMask: String):MaskedTextBox {
var tType = null
var sTip = ''
return AddMaskedTextBox(sText, sMask,tType, sTip)
} // AddMaskedTextBox method

function AddMaskedTextBox(sText: String, sMask: String, tType: Type):MaskedTextBox {
var sTip = ''
return AddMaskedTextBox(sText, sMask,tType, sTip)
} // AddMaskedTextBox method

function AddMaskedTextBox(sText: String, sMask: String, tType:Type, sTip: String):MaskedTextBox {
// Add a MaskedTextBox

if (!sText) var sText = ''
if (!sMask) var sMask = ''
if (!tType) var tType = null
if (!sTip) var sTip = ''

var txt:MaskedTextBox = new MaskedTextBox()
var iWidth = txt.Width
txt.Width = 2 * iWidth
txt.Text = sText
txt.Mask = sMask
txt.ValidatingType = tType
txt.BeepOnError = true
// txt.InsertKeyMode = System.Windows.Forms.InsertKeyMode.Overwrite
txt.ResetOnPrompt = true
txt.ResetOnSpace = true

var sName = 'MaskedTextBox_'
var lbl = CurrentControl()
if (lbl != null) {
txt.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'MaskedTextBox_')
}
txt.Name = sName
this.Widgets[sName] = txt
this.Aliases[sName] = txt.AccessibleName
if (sTip) this.FocusTips[sName] = sTip

txt.add_TypeValidationCompleted(Delegate.CreateDelegate(TypeValidationEventHandler, this, 'HandleTypeValidationCompleted'))
txt.add_Validating(Delegate.CreateDelegate(CancelEventHandler, this, 'HandleValidating'))
txt.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
// txt.add_SelectionChanged(Delegate.CreateDelegate(EventHandler, this, 'HandleSelectionChanged'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(txt)
return txt
} // AddMaskedTextBox method

function AddMemo():RichTextBox {
var sText = ''
var bReadOnly = false
var sTip = ''
return AddMemo(sText, bReadOnly, sTip)
} // AddMemo method

function AddMemo(sText: String, bReadOnly):RichTextBox {
var sTip = ''
return AddMemo(sText, bReadOnly, sTip)
} // AddMemo method

function AddMemo(sText: String, bReadOnly, sTip: String):RichTextBox {
// Add a multiline memo

if (!sText) var sText = ''
if (!bReadOnly) var bReadOnly = false
if (!sTip) var sTip = ''

// var txt:RichRichTextBox = new RichRichTextBox()
var txt:RichTextBox = new RichTextBox()
txt.Multiline = true
var iWidth = txt.Width
var iHeight = txt.Height
// txt.Width = 4 * iWidth
// txt.Height = 4 * iHeight
txt.Width = 300
txt.Height = 300
txt.Text = sText
txt.ReadOnly = bReadOnly
// No such property in RichTextBox
// if (!bReadOnly) txt.AcceptsReturn = true
txt.ScrollBars = RichTextBoxScrollBars.Vertical | RichTextBoxScrollBars.Horizontal
// txt.ScrollBars = ScrollBars.Vertical
// Next two lines are actually defaults so not necessary
txt.AcceptsTab = false
txt.WordWrap = true

var sName = 'Memo_'
var lbl = CurrentControl()
if (lbl != null) {
txt.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'Memo_')
}
txt.Name = sName
this.Widgets[sName] = txt
this.Aliases[sName] = txt.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
txt.add_Validating(Delegate.CreateDelegate(CancelEventHandler, this, 'HandleValidating'))
txt.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
txt.add_LostFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleLostFocus'))
// Only in RichTextBox
txt.add_SelectionChanged(Delegate.CreateDelegate(EventHandler, this, 'HandleSelectionChanged'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(txt)
return txt
} // AddMemo method

function AddMemoBox(sLabel: String):RichTextBox {
var sText = ''
var bReadOnly = false
var sTip = ''
return AddMemoBox(sLabel, sText, bReadOnly, sTip)
} // AddMemoBox method

function AddMemoBox(sLabel: String, sText: String, bReadOnly):RichTextBox {
var sTip = ''
return AddMemoBox(sLabel, sText, bReadOnly, sTip)
} // AddMemoBox method

function AddMemoBox(sLabel: String, sText: String, bReadOnly, sTip: String):RichTextBox {
// Add a labeled memo

if (!sLabel) var sLabel = ''
if (!sText) var sText = ''
if (!bReadOnly) var bReadOnly = false
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
// var txt:RichRichTextBox = AddMemo(sText, bReadOnly)
var txt:RichTextBox = AddMemo(sText, bReadOnly, sTip)
// return [lbl, txt]
return txt
} // AddMemoBox method

function AddMenu(sText: String):ToolStripMenuItem {
var sTip = ''
return AddMenu(sText, sTip)
} // AddMenu method

function AddMenu(sText: String, sTip: String):ToolStripMenuItem {
// Add a menu pulldown

var menu = CreateMenu(sText)
this.MainMenuStrip.Items.Add(menu)
if (sText == "Window" && this.IsMdiContainer) {
this.MainMenuStrip.MdiWindowListItem = menu
this.AddMenuItem('Arrange Icons', 'Alt+F11', 'Arrange child windows')
this.AddMenuItem('Cascade', 'Control+F11', 'Cascade child windows')
this.AddMenuItem('Tile Horizontal', 'Control+Shift+F11', 'Tile child windows horizontally')
this.AddMenuItem('Tile Vertical', 'Alt+Shift+F11', 'Tile child windows vertically')
} // if Window

menu.add_Paint(Delegate.CreateDelegate(PaintEventHandler, this, 'HandlePaint'))
return menu
} // AddMenu method

function AddMenuItem(sText: String):ToolStripMenuItem {
var sKey = ''
var sTip = ''
return AddMenuItem(sText, sKey, sTip)
} // AddMenuItem method

function AddMenuItem(sText: String, sKey: String):ToolStripMenuItem {
var sTip = ''
return AddMenuItem(sText, sKey, sTip)
} // AddMenuItem method

function AddMenuItem(sText: String, sKey: String, sTip: String):ToolStripMenuItem {
// Add a menu item and accelerator key

var menu = CurrentMenu()
var menuItem = CreateMenuItem(sText, sKey, sTip)
menu.DropDownItems.Add(menuItem)
menuItem.add_Paint(Delegate.CreateDelegate(PaintEventHandler, this, 'HandlePaint'))
return menuItem
} // AddMenuItem method

function AddMultiCheckBox(sLabel: String): CheckedListBox {
var aItems = []
var aSelect = Jax.JsInitArray(false, aItems.length)
var bSort = false
var iIndex = 0
var sTip = ''
return AddMultiCheckBox(sLabel, aItems, aSelect, bSort, iIndex, sTip)
} // AddMultiCheckBox method

function AddMultiCheckBox(sLabel: String, aItems, aSelect, bSort: Boolean, iIndex: Int32):CheckedListBox {
var sTip = ''
return AddMultiCheckBox(sLabel, aItems, aSelect, bSort, iIndex, sTip)
} // AddMultiCheckBox method

function AddMultiCheckBox(sLabel: String, aItems, aSelect, bSort: Boolean, iIndex: Int32, sTip: String):CheckedListBox {
// Add a labeled checked listbox

if (!sLabel) var sLabel = ''
if (!aItems) var aItems = []
if (!aSelect) var aSelect = Jax.JsInitArray(false, aItems.length)
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var lst:CheckedListBox = AddCheckedListBox(aItems, aSelect, bSort, iIndex, sTip)
return lst
} // AddMultiCheckBox method

function AddMultiListBox(): ListBox {
var aItems = []
var aSelect = Jax.JsInitArray(false, aItems.length)
var bSort = false
var iIndex = 0
var sTip = ''
return AddMultiListBox(aItems, aSelect, bSort, iIndex, sTip)
} // AddMultiListBox method

function AddMultiListBox(aItems, aSelect, bSort: Boolean, iIndex: Int32):ListBox {
var sTip = ''
return AddMultiListBox(aItems, aSelect, bSort, iIndex, sTip)
} // AddMultiListBox method

function AddMultiListBox(aItems, aSelect, bSort: Boolean, iIndex: Int32, sTip: String):ListBox {
// Add a multiple selection listbox

if (!aItems) var aItems = []
if (!aSelect) var aSelect = Jax.JsInitArray(false, aItems.length)
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0

var lst:ListBox = new ListBox()
lst.SelectionMode = SelectionMode.MultiSimple
for (var i = 0; i < aItems.length; i++) {
lst.Items.Add(aItems[i])
Support.SetItemData(lst, i, i)
continue
var bState = aSelect[i]
if (!bState) bState = false
lst.SetSelected(i, bState)
}

lst.Sorted = bSort
if (iIndex >= 0 && lst.Items.Count) lst.SelectedIndex = iIndex

var sName = 'MultiListBox_'
var lbl = CurrentControl()
// if (lbl) {
if (lbl != null) {
lst.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'MultiListBox_')
}
lst.Name = sName
this.Widgets[sName] = lst
this.Aliases[sName] = lst.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
lst.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
// Does not work as expected for this type of control, use MultiCheck instead
// lst.add_SelectedIndexChanged(Delegate.CreateDelegate(EventHandler, this, 'HandleSelectedIndexChanged'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(lst)
return lst
} // AddMultiListBox method

function AddMultiPickBox(sLabel: String): ListBox {
var aItems = []
var aSelect = Jax.JsInitArray(false, aItems.length)
var bSort = false
var iIndex = 0
var sTip = ''
return AddMultiPickBox(sLabel, aItems, aSelect, bSort, iIndex, sTip)
} // AddMultiPickBox method

function AddMultiPickBox(sLabel: String, aItems, aSelect, bSort: Boolean, iIndex: Int32):ListBox {
var sTip = ''
return AddMultiPickBox(sLabel, aItems, aSelect, bSort, iIndex, sTip)
} // AddMultiPickBox method

function AddMultiPickBox(sLabel: String, aItems, aSelect, bSort: Boolean, iIndex: Int32, sTip: String):ListBox {
// Add a labeled multiple selection listbox

if (!sLabel) var sLabel = ''
if (!aItems) var aItems = []
if (!aSelect) var aSelect = Jax.JsInitArray(false, aItems.length)
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var lst:ListBox = AddMultiListBox(aItems, aSelect, bSort, iIndex, sTip)
// return [lbl, lst]
return lst
} // AddMultiPickBox method

function AddNumericUpDown(): NumericUpDown {
var sText = ''
var iValue = null
var iMinValue = null
var iMaxValue = null
var sTip = ''
return AddNumericUpDown(sText, iValue, iMinValue, iMaxValue, sTip)
} // AddNumericUpDown method

function AddNumericUpDown(sText: String, iValue: Int32, iMinValue: Int32, iMaxValue: Int32):NumericUpDown {
var sTip = ''
return AddNumericUpDown(sText, iValue, iMinValue, iMaxValue, sTip)
} // AddNumericUpDown method

function AddNumericUpDown(sText: String, iValue: Int32, iMinValue: Int32, iMaxValue: Int32, sTip: String):NumericUpDown {
// Add a NumericUpDown control

if (!sText) var sText = ''
if (!iValue) var iValue = null
if (!iMinValue) var iMinValue = null
if (!iMaxValue) var iMaxValue = null

var nup: NumericUpDown = new NumericUpDown()
if (iValue) nup.Value = iValue
if (iMinValue) nup.Minimum = iMinValue
if (iMaxValue) nup.Maximum = iMaxValue
var sName = 'NumericUpDown_'
nup.AccessibleName = Lbc.MakeAccessibleName(sText)
var sName = Lbc.MakeName(nup, sText)
nup.Name = sName
this.Widgets[sName] = nup
this.Aliases[sName] = nup.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
nup.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(nup)
return nup
} // AddNumericUpDown method

function AddPickBox(sLabel: String): ListBox {
var aItems = []
var bSort = false
var iIndex = 0
var sTip = ''
return AddPickBox(sLabel, aItems, bSort, iIndex, sTip)
} // AddPickBox method

function AddPickBox(sLabel: String, aItems):ListBox {
var aItems = []
var bSort = false
return AddPickBox(sLabel, aItems, bSort)
} // AddPickBox method

function AddPickBox(sLabel: String, aItems, bSort: Boolean):ListBox {
var iIndex = 0
return AddPickBox(sLabel, aItems, bSort, iIndex)
} // AddPickBox method

function AddPickBox(sLabel: String, aItems, bSort: Boolean, iIndex: Int32):ListBox {
var sTip = ''
return AddPickBox(sLabel, aItems, bSort, iIndex, sTip)
} // AddPickBox method

function AddPickBox(sLabel: String, aItems, bSort: Boolean, iIndex: Int32, sTip: String):ListBox {
// Add a labeled listbox

if (!sLabel) var sLabel = ''
if (!aItems) var aItems = []
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel)
var lst:ListBox = AddListBox(aItems, bSort, iIndex, sTip)
// return [lbl, lst]
return lst
} // AddPickBox method

function AddPictureBox(): PictureBox {
var sFile = ''
var sTip = ''
return AddPictureBox(sFile, sTip)
} // AddPictureBox method

function AddPictureBox(sFile: String):PictureBox {
var sTip = ''
return AddPictureBox(sFile, sTip)
} // AddPictureBox method

function AddPictureBox(sFile: String, sTip: String):PictureBox {
// Add a PictureBox

if (!sFile) var sFile = ''

var pb:PictureBox = new PictureBox()
pb.SizeMode = PictureBoxSizeMode.AutoSize
// pb.SizeMode = PictureBoxSizeMode.StretchImage
// pb.ImageFile = sFile
// pb.Load()
pb.Image = Image.FromFile(sFile)

var sName = 'PictureBox_'
var lbl = CurrentControl()
if (lbl != null) {
pb.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'PictureBox_')
}
pb.Name = sName
this.Widgets[sName] = pb
this.Aliases[sName] = pb.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
pb.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(pb)
return pb
} // AddPictureBox method

function AddProgressBar(): ProgressBar {
var iMinValue = 0
var iMaxValue = 100
var iStep = 1
var sTip = ''
return AddProgressBar(iMinValue, iMaxValue, iStep, sTip)
} // AddProgressBar method

function AddProgressBar(iMinValue: Int32, iMaxValue: Int32, iStep: Int32):ProgressBar {
var sTip = ''
return AddProgressBar(iMinValue, iMaxValue, iStep, sTip)
} // AddProgressBar method

function AddProgressBar(iMinValue: Int32, iMaxValue: Int32, iStep: Int32, sTip: String):ProgressBar {
// Add a progress bar

if (!iMinValue) var iMinValue = 0
if (!iMaxValue) var iMaxValue = 100
if (!iStep) var iStep = 1

var pb: ProgressBar = new ProgressBar()
pb.Minimum = iMinValue
pb.Maximum = iMaxValue
pb.Step = 1
pb.Value = pb.Minimum
var sName = 'ProgressBar_'
pb.AccessibleName = ''
pb.Name = sName
this.Widgets[sName] = pb
this.Aliases[sName] = pb.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
// pb.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(pb)
return pb
} // AddProgressBar method

function AddRadioButton(sText: String):RadioButton {
var bState = false
var sTip = ''
return AddRadioButton(sText, bState, sTip)
} // AddRadioButton method

function AddRadioButton(sText: String, bState: Boolean):RadioButton {
var sTip = ''
return AddRadioButton(sText, bState, sTip)
} // AddRadioButton method

function AddRadioButton(sText: String, bState: Boolean, sTip: String):RadioButton {
// Add a RadioButton

if (!sText) var sText = ''
if (!bState) var bState = false

var rbn:RadioButton = new RadioButton()
rbn.Checked = bState
var sText = Lbc.MakeCaption(sText)
rbn.Text = sText
rbn.AccessibleName = Lbc.MakeAccessibleName(sText)
var sName = Lbc.MakeName(rbn, sText)
rbn.Name = sName
this.Widgets[sName] = rbn
this.Aliases[sName] = rbn.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
rbn.add_Click(Delegate.CreateDelegate(EventHandler, this, 'HandleClick'))
rbn.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(rbn)
return rbn
} // AddRadioButton method

function AddStatus(sText: String) {
// Append status text

var sStatus = sText
var sOldStatus = GetStatus()
if (sOldStatus) sStatus = sOldStatus + '   ' + sStatus
return SetStatus(sStatus)
} // AddStatus method

function AddStatusBar():StatusStrip {
// Add a status bar

var sb:StatusStrip = new StatusStrip()
sb.AccessibleRole = System.Windows.Forms.AccessibleRole.StatusBar
sb.Dock = DockStyle.Bottom
// sb.Width = 500
sb.AutoSize = true
// Acc.Say('width ' + sb.Width)
// Acc.Say('Height ' + sb.Height)
// sb.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink
// var lblStatus = new ToolStripStatusLabel('Ready')
var lblStatus = new ToolStripStatusLabel('                              ')
lblStatus.AutoSize = true
// No such property for this control
// lblStatus.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink
sb.Items.Add(lblStatus)
var sName = 'StatusBar'
sb.Name = sName
this.Widgets[sName] = sb
this.Controls.Add(sb)
return sb
} // AddStatusBar method

function AddTextBox(): TextBox {
var sText = ''
var sTip = ''
return AddTextBox(sText, sTip)
} // AddTextBox method

function AddTextBox(sText: String):TextBox {
var sTip = ''
return AddTextBox(sText, sTip)
} // AddTextBox method

function AddTextBox(sText: String, sTip: String):TextBox {
// Add a textbox

if (!sText) var sText = ''
if (!sTip) var sTip = ''

var txt:TextBox = new TextBox()
var iWidth = txt.Width
txt.Width = 2 * iWidth
txt.Text = sText
var sName = 'TextBox_'
var lbl = CurrentControl()
if (lbl != null) {
txt.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'TextBox_')
}
txt.Name = sName
this.Widgets[sName] = txt
this.Aliases[sName] = txt.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
// this.add_KeyDown(Delegate.CreateDelegate(KeyEventHandler, this, 'HandleKeyDown'))
txt.add_Validating(Delegate.CreateDelegate(CancelEventHandler, this, 'HandleValidating'))
txt.add_Paint(Delegate.CreateDelegate(PaintEventHandler, this, 'HandlePaint'))
txt.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
// txt.add_SelectionChanged(Delegate.CreateDelegate(EventHandler, this, 'HandleSelectionChanged'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(txt)
return txt
} // AddTextBox method

function AddTimePicker():DateTimePicker {
var dtValue = null
var dtMinValue = null
var dtMaxValue = null
var sTip = ''
return AddTimePicker(dtValue, dtMinValue, dtMaxValue, sTip)
} // AddTimePicker method

function AddTimePicker(dtValue, dtMinValue, dtMaxValue):DateTimePicker {
var sTip = ''
return AddTimePicker(dtValue, dtMinValue, dtMaxValue, sTip)
} // AddTimePicker method

function AddTimePicker(dtValue, dtMinValue, dtMaxValue, sTip: String):DateTimePicker {
// Add a time picker

if (!dtValue) var dtValue = null
if (!dtMinValue) var dtMinValue = null
if (!dtMaxValue) var dtMaxValue = null

var dtp: DateTimePicker = new DateTimePicker()
// dtp.MinDate = new DateTime(1985, 6, 20)
// dtp.MaxDate = DateTime.Today
if (dtValue) dtp.Value = dtValue
if (dtMinValue) dtp.MinDate = dtMinValue
if (dtMaxValue) dtp.MaxDate = dtMaxValue
dtp.Format = DateTimePickerFormat.Time

dtp.ShowCheckBox = false
dtp.ShowUpDown = true
var sName = 'TimePicker_'
var lbl = CurrentControl()
if (lbl != null) {
dtp.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'TimePicker_')
}
dtp.Name = sName
this.Widgets[sName] = dtp
this.Aliases[sName] = dtp.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
dtp.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(dtp)
return dtp
} // AddTimePicker method

function AddTimePickerBox(sLabel: String):DateTimePicker {
var dtValue = null
var dtMinValue = null
var dtMaxValue = null
var sTip = ''
return AddTimePickerBox(sLabel, dtValue, dtMinValue, dtMaxValue, sTip)
} // AddTimePickerBox

function AddTimePickerBox(sLabel: String, dtValue, dtMinValue, dtMaxValue):DateTimePicker {
var sTip = ''
return AddTimePickerBox(sLabel, dtValue, dtMinValue, dtMaxValue, sTip)
} // AddTimePickerBox

function AddTimePickerBox(sLabel: String, dtValue, dtMinValue, dtMaxValue, sTip: String):DateTimePicker {
// Add a labeled time picker

if (!sLabel) var sLabel = ''
if (!dtValue) var dtValue = null
if (!dtMinValue) var dtMinValue = null
if (!dtMaxValue) var dtMaxValue = null
if (!sTip) var sTip = ''

var lbl:Label = null
if (sLabel) lbl = AddLabel(sLabel, sTip)
var dtp:DateTimePicker = AddTimePicker(dtValue, dtMinValue, dtMaxValue, sTip)
return dtp
} // AddTimePickerBox method

function AddTimer():System.Windows.Forms.Timer {
var iInterval = 1000
var sTip = ''
return AddTimer(iInterval, sTip)
} // AddTimer method

function AddTimer(iInterval: Int32): System.Windows.Forms.Timer {
var sTip = ''
return AddTimer(iInterval, sTip)
} // AddTimer method

function AddTimer(iInterval: Int32, sTip: String): System.Windows.Forms.Timer {
// Add a timer

if (!iInterval) var iInterval = 1000

var tmr: System.Windows.Forms.Timer = new System.Windows.Forms.Timer()
tmr.Interval = iInterval

var sName = 'Timer_'
// tmr.AccessibleName = ''
// tmr.Name = sName
this.Widgets[sName] = tmr
// this.Aliases[sName] = tmr.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
tmr.add_Tick(Delegate.CreateDelegate(EventHandler, this, 'HandleTick'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(tmr)
return tmr
} // AddTimer method

function AddTreeNodes(tv, oCurrentNode, aSubNodes) {
var oNode:TreeNode = null
if (oCurrentNode) oNode = oCurrentNode
else {
oNode = new TreeNode()
tv.Nodes.Add(oNode)
}
oNode.Text = aSubNodes[0]

for (var i = 1; i < aSubNodes.length; i++) {
var o = aSubNodes[i]
var sType = typeof(o)
if (sType == 'string') oNode.Nodes.Add(o)
else AddTreeNodes(tv, oNode, o)
}
} // AddTreeNodes method

function AddTreeView():TreeView {
var aNodes = []
var bSort = false
var iIndex = 0
var sTip = ''
return AddTreeView(aNodes, bSort, iIndex, sTip)
} // AddTreeView method

function AddTreeView(aNodes):TreeView {
var bSort = false
var iIndex = 0
var sTip = ''
return AddTreeView(aNodes, bSort, iIndex, sTip)
} // AddTreeView method


function AddTreeView(aNodes, bSort: Boolean):TreeView {
var iIndex = 0
var sTip = ''
return AddTreeView(aNodes, bSort, iIndex, sTip)
} // AddTreeView method


function AddTreeView(aNodes, bSort: Boolean, iIndex: Int32):TreeView {
var sTip = ''
return AddTreeView(aNodes, bSort, iIndex, sTip)
} // AddTreeView method

function AddTreeView(aNodes, bSort: Boolean, iIndex: Int32, sTip: String):TreeView {
// Add a TreeView

if (!aNodes) var aNodes = []
if (!bSort) var bSort = false
if (!iIndex) var iIndex = 0

var tv:TreeView = new TreeView()
tv.FullRowSelect = true
tv.ShowRootLines = true
tv.ShowLines = true
tv.ShowPlusMinus = true
if (bSort) tv.Sorted = true
// AddTreeNodes(tv, null, aNodes)
for (var i = 0; i < aNodes.length; i++){
var aBranch = aNodes[i]
AddTreeNodes(tv, null, aBranch)
}

// if (iIndex >= 0 && tv.Items.Count) tv.Items(iIndex).Focused = true

var sName = 'TreeView_'
var lbl = CurrentControl()
if (lbl != null) {
tv.AccessibleName = lbl.AccessibleName
sName = lbl.Name.replace('Label_', 'TreeView_')
}
tv.Name = sName
this.Widgets[sName] = tv
this.Aliases[sName] = tv.AccessibleName
if (sTip) this.FocusTips[sName] = sTip
tv.add_GotFocus(Delegate.CreateDelegate(EventHandler, this, 'HandleGotFocus'))
tv.add_AfterSelect(Delegate.CreateDelegate(TreeViewEventHandler, this, 'HandleAfterSelect'))
tv.add_AfterCollapse(Delegate.CreateDelegate(TreeViewEventHandler, this, 'HandleAfterCollapse'))
this.MainPanel.Controls(CurrentBand()).Controls.Add(tv)
return tv
} // AddTreeView method

function AlternateMenu() {
var aNames = []
var aValues = []
for (var oMenu: ToolStripMenuItem in this.MainMenuStrip.Items) {
// for (var oItem: ToolStripMenuItem in oMenu.DropDownItems) {
for (var o in oMenu.DropDownItems) {
if (!o.GetType().ToString().EndsWith('MenuItem')) continue
var oItem: ToolStripMenuItem = o
if (!oItem) continue
var sName = oItem.Name
if (sName == 'MenuItem_Alternate_Menu') continue

var sText = Lbc.MakeAccessibleName(oItem.Text)
var sKey = oItem.ShortcutKeyDisplayString
var sTip = this.FocusTips[sName]
if (sKey) {
sText = sText + ' = ' + sKey
if (sTip) sText = sText + ', ' + sTip
}
else if (sTip) sText = sText + ' = ' + sTip

aNames.push(sText)
aValues.push(oItem)
} // j
} // i
var oResult: ToolStripMenuItem = Lbc.DialogPick('Alternate Menu', "", aNames, aValues, true)
if (!oResult) return
oResult.PerformClick()
} // AlternateMenu method

function ClearStatus() {
// Clear status text

// Acc.Say('Clearing ' + this.Text)
var sb:StatusStrip = this.Controls['StatusBar']
var lbl = sb.Items(0)
lbl.Text = ''

for (var i = 0; i < this.MdiChildren.Length; i++) {
var child: LbcForm = this.MdiChildren[i]
child.ClearStatus()
}
} // ClearStatus method

function Complete(aButtons, iFocus: Int32, dFocusTips: Hashtable):Button[] {
// Complete a dialog with a button band and focus position

MessageBox.Show(aButtons.GetType())
// if (!aButtons || aButtons.length) {
if (!Jax.JsIsNone(aButtons)) {
var a = AddButtonBand(aButtons)
this.AcceptButton = a[0]
}
if (!iFocus) var iFocus = 0

// Acc.Say('MdiParent ' + this.MdiParent)
// Acc.Say('Owner ' + this.Owner)
// Returns undefined not null
// if (this.MdiParent == null || this.Owner == null) {
if (true) {
// if (!this.MdiParent && !this.Owner) {
// Acc.Say('adding status bar for ' + this.Text)
AddStatusBar()
this.Controls.Add(this.MainMenuStrip)
this.StartPosition = FormStartPosition.CenterScreen
}
else {
this.StartPosition = FormStartPosition.CenterParent
// this.WindowState = FormWindowState.Maximized
}

var frm: LbcForm = Form.ActiveForm
// if ((this.MdiParent || this.Owner) && this.Widgets['StatusBar']) {
// if (frm) Acc.Say('frm ' + frm.Text)
// if (frm && (frm.MdiParent || frm.Widgets['StatusBar']) && this.Widgets['StatusBar']) {
if (frm) {
var ctl = this.Controls['StatusBar']
// this.Controls.Remove(ctl)
}

if (this.IsMdiContainer) {
this.Controls.RemoveAt(0)
this.Size = new System.Drawing.Size(600, 600)
}
else this.AutoSize = true
this.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink
// this.AutoScroll = true

// Causes error on Vista related to lack of object reference
// this.add_Load(Delegate.CreateDelegate(EventHandler, this, 'HandleLoad'))
this.add_Shown(Delegate.CreateDelegate(EventHandler, this, 'HandleShown'))
this.add_Closing(Delegate.CreateDelegate(CancelEventHandler, this, 'HandleClosing'))
// Acc.Say('form type ' + this.GetType())
// if (!this.IsMdiContainer) this.KeyPreview = true
// if (!this.MdiParent) this.KeyPreview = true
this.KeyPreview = true
this.add_KeyDown(Delegate.CreateDelegate(KeyEventHandler, this, 'HandleKeyDown'))

var aItems = Lbc.CollectionToArray(this.Widgets)
// Start at 1 not 0
for (var i = 1; i < this.Widgets.Count; i++) {
if (i == iFocus) {
// var ctl = this.Widgets[i]
// var ctl = this.Widgets.Item(i)
var ctl = aItems[i].Value
// ctl.Select()
ctl.Focus()
break
}
}

// if (this.IsDialog) this.Width = 500
this.ResumeLayout()

this.LastAcceptButton = this.AcceptButton
var frmOwner: Form = Form.ActiveForm
if (frmOwner && frmOwner.ActiveMdiChild) frmOwner = frmOwner.ActiveMdiChild
// Acc.Say('IsDialog ' + this.IsDialog)
// if (this.IsDialog) this.ShowDialog(frmOwner)
// if (this.IsDialog) this.ShowDialog()
if (this.IsDialog) {
// Acc.Say('Handler ' + this.Handler)
this.ShowDialog() 
}

else {
this.Show()
// this.Activate()
}
} // Complete method

function CompleteDialog():Button[] {
// var aButtons = []
var aButtons = null
var iFocus = 0
var dFocusTips = new Hashtable()
return CompleteDialog(aButtons, iFocus, dFocusTips)
} // CompleteDialog method

function CompleteDialog(aButtons):Button[] {
var iFocus = 0
var dFocusTips = new Hashtable()
return CompleteDialog(aButtons, iFocus, dFocusTips)
} // CompleteDialog method

function CompleteDialog(aButtons, iFocus: Int32):Button[] {
var dFocusTips = new Hashtable()
return CompleteDialog(aButtons, iFocus, dFocusTips)
} // CompleteDialog method

function CompleteDialog(aButtons, iFocus: Int32, dFocusTips: Hashtable):Button[] {
this.IsDialog = true
return Complete(aButtons, iFocus, dFocusTips)
} // CompleteDialog method

function CompleteWindow():Button[] {
var aButtons = []
var iFocus = null
return CompleteWindow(aButtons, iFocus)
} // CompleteWindow method

function CompleteWindow(aButtons, iFocus: Int32):Button[] {
this.IsDialog = false
return Complete(aButtons, iFocus)
} // CompleteWindow method

function ConfigurationOptions() {
var aNames = Ini.ReadKeys()
// var aValues = new string[aNames.Length]
var aValues = []
var aMasks = []
var aTypes = []
var dTips = new Hashtable()
for (var i = 0; i < aNames.length; i++) {
var sName = aNames[i]
var sValue = Ini.ReadString(sName)
var sMask = Ini.ReadValue(Ini.DefaultIniFile, Ini.IniSection + " Masks", sName, "")
var sType = Ini.ReadValue(Ini.DefaultIniFile, Ini.IniSection + " Types", sName, "")
var sTip: String = Ini.ReadValue(Ini.DefaultIniFile, Ini.IniSection + " Tips", sName, "")
aValues[i] = sValue
aMasks[i] = sMask
var sExp = 'new ' + sType + '()'
var oType = eval(sExp, 'unsafe')
var tType = oType.GetType()
aTypes[i] = tType
// aTips[i] = sTip
var sWidgetName: String = Lbc.MakeName(new MaskedTextBox(), sName)
// Lbc.DialogShow(sWidgetName, sTip)
dTips[sWidgetName] = sTip
} // for
// for (var sKey in dTips) Lbc.DialogShow(sKey, dTips[sKey])

// aValues = Lbc.DialogMultiInput("Configuration Options", aNames, aValues)
var iFocus = 0
aValues = Lbc.DialogMultiMaskedInput("Configuration Options", aNames, aValues, aMasks, aTypes, iFocus, dTips)
if (aValues.length == 0) return true

for (var i = 0; i < aValues.Length; i++) {
sName = aNames[i]
sValue = aValues[i]
Ini.WriteString(sName, sValue)
} // for
} // ConfigurationOptions method

function CreateFlowPanel(direction) {
// Create a FlowLayoutPanel

var flp = new FlowLayoutPanel()
flp.FlowDirection = direction
flp.AutoSize = true
flp.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink
return flp
} // CreateFlowPanel method

function CreateHorizontalPanel() {
// Create a horizontal FlowLayoutPanel

return CreateFlowPanel(FlowDirection.LeftToRight)
} // CreateHorizontalPanel method

function CreateMainMenu():MenuStrip {
// Create the main menu of the dialog

var menuMain:MenuStrip = new MenuStrip()
menuMain.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuBar
menuMain.Dock = DockStyle.Top
/*
menuMain.AutoSize = true
menuMain.CanOverflow = false
menuMain.LayoutStyle = ToolStripLayoutStyle.Flow
menuMain.Stretch = false
*/
return menuMain
} // CreateMainMenu method

function CreateMenu(sText: String) {
// Create a menu pulldown

var menu = new ToolStripMenuItem(sText)
// menu.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuItem
menu.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuPopup
menu.Text = sText
menu.Name = sText
return menu
} // CreateMenu method

function CreateMenuItem(sText: String, sKey: String, sTip: String) {
// Create a menu item

if (!sText) var sText = ''
if (!sKey) var sKey = ''
if (!sTip) var sTip = ''
var oImage = null
var oHandler = Delegate.CreateDelegate(EventHandler, this, 'HandleClick')
var menuItem = new ToolStripMenuItem(sText, , oHandler,)
menuItem.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuItem
// ReadOnly
// menuItem.ShowKeyboardCues = true
menuItem.ShowShortcutKeys = true
sText = Lbc.MakeCaption(sText)
menuItem.Text = sText
var oKey = Lbc.StringToKey(sKey)
menuItem.ShortcutKeys = oKey
var sFriendlyKey = Lbc.MakeFriendlyKeyName(sKey)
menuItem.ShortcutKeyDisplayString = sFriendlyKey
var sName = Lbc.MakeAccessibleName(sText)
menuItem.AccessibleName = sName + '   ' + sFriendlyKey
sName = sName.Replace(' ', '_')
sName = 'MenuItem_' + sName
menuItem.Name = sName
this.Widgets[sName] = menuItem
this.Aliases[sName] = menuItem.AccessibleName
if (sTip) this.FocusTips[sName] = sTip

/*
menuItem.Tag = sOptions
menuItem.ToolTipText = sKey
menuItem.AccessibleDescription = Util.GetFriendlyKeyName(sKey)
menuItem.ShortcutKeyDisplay= sFriendlyKey
*/
return menuItem
} // CreateMenuItem method

function CreateTablePanel(iColumns: Int32, iRows: Int32) {
// Create a TableLayoutPanel

var tlp = new TableLayoutPanel()
tlp.Anchor = AnchorStyles.None
tlp.AutoSize = true
tlp.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink
//tlp.AutoScroll = true
tlp.ColumnCount = iColumns
for (var i = 0; i < tlp.ColumnCount; i++) {
tlp.ColumnStyles.Add(new ColumnStyle(SizeType.AutoSize))
}

for (var i = 0; i < tlp.RowCount; i++) {
tlp.RowStyles.Add(new RowStyle(SizeType.AutoSize))
}
return tlp
} // CreateTablePanel method

function CreateVerticalPanel() {
// Create a vertical FlowLayoutPanel

return CreateFlowPanel(FlowDirection.TopDown)
} // CreateVerticalPanel method

function CurrentBand() {
// Return the current band number

return this.MainPanel.Controls.Count - 1
} // CurrentBand method

function CurrentControl() {
// Return the control last added

var iBand = CurrentBand()
if (iBand < 0) return null

var flp = this.MainPanel.Controls(iBand)
var iIndex = flp.Controls.Count - 1
if (iIndex < 0) return null

var ctl = flp.Controls(iIndex)
return ctl
} // CurrentControl method

function CurrentMenu() {
// Return the menu pulldown last added

if (this.MainMenuStrip == null) return null
var iIndex = this.MainMenuStrip.Items.Count - 1
if (iIndex < 0) return null
var menu = this.MainMenuStrip.Items(iIndex)
return menu
} // CurrentMenu method

function CurrentMenuItem() {
// Return the menu item last added

var menu = CurrentMenu()
if (menu == null) return null

var iIndex = menu.DropDownItems.Count - 1
if (iIndex < 0) return null
var menuItem = menu.DropDownItems(iIndex)
return menuItem
} // CurrentMenuItem method

function Export(sFile: String) {
// Export data from a file into controls of the current dialog

var aItems = Lbc.CollectionToArray(this.Widgets)
for (var i = 0; i < aItems.length; i++) {
var oItem = aItems[i]
var sName = oItem.Key
// Acc.Say(sName)
if (sName.StartsWith('MenuItem_')) continue
var ctl = oItem.Value
// Acc.Say(ctl.GetType())
if (ctl.Items) {
var sText = ''
for (var j = 0; j < ctl.Items.Count; j++) {
if (sText.length) sText += '\n'
sText += ctl.Items(j).ToString()
} // j
}
else sText = ctl.Text
var s = this.Text.Replace('&', '').Replace(' ', '_')
var sPath = 'Form_' + s + '/' + sName
Jax.XmlSetValue(sFile, sPath, sText)
} // i
} // Export method

function Export() {
var sFile: String = Lbc.DialogSaveFile('Save')
if (!sFile) return

this.Export(sFile)
} // Export method

function FindControl(sClass: String) {
// Find the first control with a class name

var aItems = Lbc.CollectionToArray(this.Widgets)
for (var i = 0; i < this.Widgets.Count; i++) {
// var ctl = this.Widgets[i]
// var ctl = this.Widgets.Item(i)
var ctl = aItems[i].Value
if (ctl.Name.StartsWith(sClass + '_')) return ctl
}
return null
} // FindControl method

function GetButton(sName: String): Button {
return this.Widgets['Button_' + sName]
} // GetButton method

function GetCheckBox(sName: String): CheckBox {
return this.Widgets['CheckBox_' + sName]
} // GetCheckBox method

function GetCheckedListBox(sName: String): CheckedListBox {
return this.Widgets['CheckedListBox_' + sName]
} // GetCheckedListBox method

function GetComboBox(sName: String): ComboBox {
return this.Widgets['ComboBox_' + sName]
} // GetComboBox method

function GetDateTime(sName: String): DateTime {
return this.Widgets['DateTime_' + sName]
} // GetDateTime method

function GetDateTimePicker(sName: String): DateTimePicker {
return this.Widgets['DateTimePicker_' + sName]
} // GetDateTimePicker method

function GetDecimal(sName: String): Decimal {
return this.Widgets['Decimal_' + sName]
} // GetDecimal method

function GetLabel(sName: String): Label {
return this.Widgets['Label_' + sName]
} // GetLabel method

function GetListBox(sName: String): ListBox {
return this.Widgets['ListBox_' + sName]
} // GetListBox method

function GetListView(sName: String): ListView {
return this.Widgets['ListView_' + sName]
} // GetListView method

function GetMaskedTextBox(sName: String): MaskedTextBox {
return this.Widgets['MaskedTextBox_' + sName]
} // GetMaskedTextBox method

function GetNumericUpDown(sName: String): NumericUpDown {
return this.Widgets['NumericUpDown_' + sName]
} // GetNumericUpDown method

function GetPictureBox(sName: String): PictureBox {
return this.Widgets['PictureBox_' + sName]
} // GetPictureBox method

function GetProgressBar(sName: String): ProgressBar {
return this.Widgets['ProgressBar_' + sName]
} // GetProgressBar method

function GetRadioButton(sName: String): RadioButton {
return this.Widgets['RadioButton_' + sName]
} // GetRadioButton method

function GetString(sName: String): String {
return this.Widgets['String_' + sName]
} // GetString method

function GetTextBox(sName: String): TextBox {
return this.Widgets['TextBox_' + sName]
} // GetTextBox method

function GetToolStripMenuItem(sName: String): ToolStripMenuItem {
return this.Widgets['ToolStripMenuItem_' + sName]
} // GetToolStripMenuItem method

function GetTreeView(sName: String): TreeView {
return this.Widgets['TreeView_' + sName]
} // GetTreeView method

function GetWidgets() {
// Get an array of widgets

var aWidgets = []
for (var o in this.Widgets) aWidgets.push(o.Value)
return aWidgets
} // GetWidgets method



function GetSelectedControl() {

var aItems = Lbc.CollectionToArray(this.Widgets)
for (var i = 0; i < this.Widgets.Count; i++) {
var ctl = aItems[i].Value
// if (ctl.Focused) return ctl
if (ctl.Selected) return ctl
}
return null
} // GetSelectedControl method

function GetFocusControl() {
// Get focus control

var ctl: Object = this.ActiveControl
// Acc.Say(ctl)
while (!Jax.JsIsNone(ctl.ActiveControl)) {
// Acc.Say(ctl)
ctl = ctl.ActiveControl
} // while
return ctl
} // GetFocusControl method

function GetFocusName() {
// Get name of focus control

var ctl: Object = this.ActiveControl
// Acc.Say(ctl)
while (!Jax.JsIsNone(ctl.ActiveControl)) {
// Acc.Say(ctl)
ctl = ctl.ActiveControl
} // while
var sName = ctl.Name
return sName
} // GetFocusName method

function GetStatus() {
// Get status text

var iIndex = this.Controls.Count - 1
// var sb:StatusStrip = this.Controls(iIndex)
var sb:StatusStrip = this.Controls['StatusBar']
var lbl = sb.Items(0)
return lbl.Text
} // GetStatus method

function HandleAfterCollapse(oSender:Object, oArgs:TreeViewEventArgs) {
// Handler for AfterCollapse event

var sEvent = 'AfterCollapse'
// var sCode = this.Handler + '(sEvent, oSender, oArgs)'
// eval(sCode, 'unsafe')
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
} // HandleAfterCollapseEvent method

function HandleAfterSelect(oSender:Object, oArgs:TreeViewEventArgs) {
// Handler for AfterSelect event

var sEvent = 'AfterSelect'
// var sCode = this.Handler + '(sEvent, oSender, oArgs)'
// eval(sCode, 'unsafe')
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
} // HandleAfterSelectEvent method

function HandleClick(oSender:Object, oArgs:EventArgs) {
// Handler for Click event

var sName = Lbc.GetName(oSender)
if (this.KeyDescriber && sName != 'MenuItem_Key_Describer') {
var sAlias = this.Aliases(sName)
sAlias = sAlias.replace('   ', ' = ')
var sTip = this.FocusTips[sName]
if (!sTip) sTip = 'No tip available'
sTip = sAlias + ', ' + sTip
this.SetMessage(sTip)
return
} // if KeyDescriber

var sEvent = 'Click'
// var sCode = this.Handler + '(sEvent, oSender, oArgs)'
// eval(sCode, 'unsafe')
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

// Acc.Say('Handler ' + bHandler)
var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return

// Acc.Say(sEvent + ' ' + sName)
if (oSender == this.CancelButton) this.CancelButtonClicked = true
else this.CancelButtonClicked = false
// Acc.Say(this.CancelButtonClicked)
} // HandleClickEvent method

function HandleClosing(oSender:Object, oArgs:CancelEventArgs) {
// Handler for Closing event of a dialog

var sEvent = 'Closing'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
// Acc.Say('Closing')

if (!File.Exists(Lbc.ExportFile)) return
this.Export(Lbc.ExportFile)
} // HandleClosing method

function HandleDialogChoose(sEvent: String, oSender, oArgs) {
// Custom event handler for Choose dialog

switch (sEvent) {
case 'Shown' :
this.Result = 'Cancel'
return
case 'Click' :
this.Result = oSender.AccessibleName
this.Close()
} // sEvent
} // HandleDialogChoose method

function HandleDialogDatePicker(sEvent: String, oSender, oArgs) {
// Custom event handler for date picker dialog

var dtp = FindControl('DatePicker')
switch (sEvent) {
case 'Shown' :
this.Result = null
return
case 'Click' :
switch(oSender.Name) {
case 'Button_OK' :
this.Result = dtp.Value
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogDatePicker method

function HandleDialogInfo(sEvent: String, oSender, oArgs) {
// Custom event handler for Info dialog

switch (sEvent) {
case 'Click' :
this.Close()
return
} // sEvent
} // HandleDialogInfo method

function HandleDialogInputAndChoose(sEvent: String, oSender, oArgs) {
// Custom event handler for InputAndChoose dialog

switch (sEvent) {
case 'Shown' :
this.Result = []
return
case 'Click' :
var aResults = []
var txt = FindControl('TextBox')
aResults.push(txt.Text)
aResults.push(oSender.AccessibleName)
this.Result = aResults
this.Close()
} // sEvent
} // HandleDialogInputAndChoose method

function HandleDialogMemo(sEvent: String, oSender, oArgs) {
// Custom event handler for Memo dialog

this.Result = ''
switch (sEvent) {
case 'Click' :
switch(oSender.Name) {
case 'Button_OK' :
var txt = FindControl('Memo')
this.Result = txt.Text
break
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogMemo method

function HandleDialogMultiCheck(sEvent: String, oSender, oArgs) {
// Custom event handler for multi check dialog

switch (sEvent) {
case 'Shown' :
this.Result = []
return
case 'SelectedIndexChanged' :
var lst = FindControl('CheckedListBox')
var iIndex = lst.SelectedIndex
if (iIndex < 0) return
var iData = Support.GetItemData(lst, iIndex)
var sValue = this.ItemTips[iData]
if (sValue) SetStatus(sValue)
return
case 'Click' :
switch (oSender.Name) {
case 'Button_OK' :
var lst = FindControl('CheckedListBox')
var aResults = []
for (var i = 0; i < lst.CheckedIndices.Count; i++) {
var iIndex = lst.CheckedIndices(i)
var iData = Support.GetItemData(lst, iIndex)
aResults.push(iData)
}
this.Result = aResults
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogMultiCheck method

function HandleDialogMultiInput(sEvent: String, oSender, oArgs) {
// Custom event handler for MultiInput dialog

switch (sEvent) {
case 'Shown' :
this.Result = []
return
case 'Click' :
switch (oSender.Name) {
case 'Button_OK' :
var aResults = []
for (var i = 0; i < this.MainPanel.Controls.Count; i++) {
var flp = this.MainPanel.Controls(i)
for (var j = 0; j < flp.Controls.Count; j++) {
var ctl = flp.Controls(j)
if (ctl.Name.StartsWith('TextBox_')) aResults.push(ctl.Text)
}
}
this.Result = aResults
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogMultiInput method

function HandleDialogMultiMaskedInput(sEvent: String, oSender, oArgs) {
// Custom event handler for MultiMaskedInput dialog

// Acc.Say('Event ' + sEvent)
switch (sEvent) {
case 'Shown' :
this.Result = []
return
case 'Click' :
switch (oSender.Name) {
case 'Button_OK' :
var aResults = []
for (var i = 0; i < this.MainPanel.Controls.Count; i++) {
var flp = this.MainPanel.Controls(i)
for (var j = 0; j < flp.Controls.Count; j++) {
var ctl = flp.Controls(j)
if (ctl.Name.StartsWith('MaskedTextBox_')) aResults.push(ctl.Text)
}
}
this.Result = aResults
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogMultiMaskedInput method

function HandleDialogMultiPick(sEvent: String, oSender, oArgs) {
// Custom event handler for multi pick dialog

switch (sEvent) {
case 'Shown' :
this.Result = []
return
case 'SelectedIndexChanged' :
var lst = FindControl('MultiListBox')
var iIndex = lst.SelectedIndex
if (iIndex < 0) return
var iData = Support.GetItemData(lst, iIndex)
var sValue = this.ItemTips[iData]
if (sValue) SetStatus(sValue)
return
case 'Click' :
switch (oSender.Name) {
case 'Button_OK' :
var lst = FindControl('MultiListBox')
var aResults = []
for (var i = 0; i < lst.SelectedIndices.Count; i++) {
var iIndex = lst.SelectedIndices(i)
var iData = Support.GetItemData(lst, iIndex)
aResults.push(iData)
}
this.Result = aResults
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogMultiPick method

function HandleDialogNumberPicker(sEvent: String, oSender, oArgs) {
// Custom event handler for NumberPicker dialog

var nup = FindControl('NumericUpDown')
switch (sEvent) {
case 'Shown' :
this.Result = null
return
case 'Click' :
switch(oSender.Name) {
case 'Button_OK' :
this.Result = nup.Value
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogNumberPicker method

function HandleDialogOpenFolder(sEvent: String, oSender, oArgs) {
// Custom event handler for OpenFolder dialog

var txt = FindControl('TextBox')
var sFolder = txt.Text.Trim()
switch (sEvent) {
case 'Shown' :
this.Result = ''
return
case 'Click' :
switch (oSender.Name) {
case 'Button_Browse' :
sFolder = Lbc.DialogBrowseForFolder('', sFolder)
if (sFolder) txt.Text = sFolder
txt.Select()
txt.SelectAll()
return
case 'Button_OK' :
if (Directory.Exists(sFolder)) {
this.Result = sFolder
break
}

var sMessage = 'Cannot find folder\n' + sFolder + '\nCreate it?'
if (Lbc.DialogConfirm('', sMessage, 'Y') != 'Y') return

try {
Directory.CreateDirectory(sFolder)
this.Result = sFolder
break
}
catch (e) {
Lbc.DialogShow('Error', e.Description)
return
}
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogOpenFolder method

function HandleDialogPick(sEvent: String, oSender, oArgs) {
// Custom event handler for Pick dialog

var lst = FindControl('ListBox')
var iIndex = lst.SelectedIndex
switch (sEvent) {
case 'Shown' :
this.Result = -1
return
case 'SelectedIndexChanged' :
if (iIndex < 0) return
var iData = Support.GetItemData(lst, iIndex)
var sValue = this.ItemTips[iData]
if (sValue) SetStatus(sValue)
return
case 'Click' :
switch(oSender.Name) {
case 'Button_OK' :
if (iIndex >= 0) this.Result = Support.GetItemData(lst, iIndex)
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogPick method

function HandleDialogPickAndChoose(sEvent: String, oSender, oArgs) {
// Custom event handler for PickAndChoose dialog

switch (sEvent) {
case 'Shown' :
this.Result = []
return
case 'SelectedIndexChanged' :
var lst = FindControl('ListBox')
var iIndex = lst.SelectedIndex
if (iIndex < 0) return
var iData = Support.GetItemData(lst, iIndex)
var sValue = this.ItemTips[iData]
if (sValue) SetStatus(sValue)
return
case 'Click' :
var aResults = []
var lst = FindControl('ListBox')
var iIndex = lst.SelectedIndex
var iData = -1
if (iIndex >= 0) iData = Support.GetItemData(lst, iIndex)
aResults.push(iData)
aResults.push(oSender.AccessibleName)
this.Result = aResults
this.Close()
} // sEvent
} // HandleDialogPickAndChoose method

function HandleDialogPickInputAndChoose(sEvent: String, oSender, oArgs) {
// Custom event handler for PickInputAndChoose dialog

switch (sEvent) {
case 'Shown' :
this.Result = []
return
case 'SelectedIndexChanged' :
var lst = FindControl('ListBox')
var iIndex = lst.SelectedIndex
if (iIndex < 0) return
var iData = Support.GetItemData(lst, iIndex)
var sValue = this.ItemTips[iData]
if (sValue) SetStatus(sValue)
return
case 'Click' :
var aResults = []
var lst = FindControl('ListBox')
var iIndex = lst.SelectedIndex
var iData = -1
if (iIndex >= 0) iData = Support.GetItemData(lst, iIndex)
aResults.push(iData)
var txt = FindControl('TextBox')
aResults.push(txt.Text)
aResults.push(oSender.AccessibleName)
this.Result = aResults
this.Close()
} // sEvent
} // HandleDialogPickInputAndChoose method

function HandleDialogTimePicker(sEvent: String, oSender, oArgs) {
// Custom event handler for time picker dialog

var dtp = FindControl('TimePicker')
switch (sEvent) {
case 'Shown' :
this.Result = null
return
case 'Click' :
switch(oSender.Name) {
case 'Button_OK' :
this.Result = dtp.Value
} // oSender.Name
this.Close()
} // sEvent
} // HandleDialogTimePicker method

function HandleDoWork(oSender:Object, oArgs:DoWorkEventArgs) {
// Handler for DoWork event

var sEvent = 'DoWork'
// var sCode = this.Handler + '(sEvent, oSender, oArgs)'
// eval(sCode, 'unsafe')
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
} // HandleDoWorkEvent method

function HandleGotFocus(oSender:Object, oArgs:EventArgs) {
// Handler for GotFocus event of a control

var sEvent = 'GotFocus'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return

var sName = Lbc.GetName(oSender)
if (sName.StartsWith('MaskedTextBox_')) oSender.SelectAll()
if (sName.StartsWith('Memo_')) this.AcceptButton = null

var sText = this.FocusTips[sName]
if (!sText) sText = ''
SetStatus(sText)
} // HandleGotFocusEvent method

function HandleKeyDown(oSender:Object, oArgs:KeyEventArgs) {
// Handler for KeyDown event

var sEvent = 'KeyDown'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
if (!this.ExtraKeys) return

var sName = this.GetFocusName()
// Acc.Say('sender ' + oSender.GetType())
var oKey = oArgs.KeyData
switch(oKey) {
case Keys.F8 :
case Keys.Shift | Keys.F8 :
case Keys.Control | Keys.F8 :
case Keys.Alt | Keys.F8 :
case Keys.Control | Keys.C :
case Keys.Alt | Keys.C :
case Keys.Control | Keys.X :
case Keys.Alt | Keys.X :
case Keys.Alt | Keys.Y :
case Keys.Shift | Keys.F5 :

if (!sName.StartsWith('TextBox_') && !sName.StartsWith('Memo_')) return

// Cannot cast RichTextBox to TextBox
// var txt: TextBox = this.Widgets[sName]
var txt = this.Widgets[sName]
if (oKey == Keys.F8) this.StartSelection()
// Parens needed around key combination
// else if (oKey == Keys.Shift | Keys.F8) {
else if (oKey == (Keys.Shift | Keys.F8)) this.CompleteSelection()
else if (oKey == (Keys.Control | Keys.F8)) this.CopyAll()
else if (oKey == (Keys.Alt | Keys.F8)) this.ReadAll()
else if (oKey == (Keys.Control | Keys.C)) this.Copy()
else if (oKey == (Keys.Alt | Keys.C)) this.CopyAppend()
else if (oKey == (Keys.Control | Keys.X)) this.Cut()
else if (oKey == (Keys.Alt | Keys.X)) this.CutAppend()
else if (oKey == (Keys.Alt | Keys.Y)) this.SayYield()
else if (oKey == (Keys.Shift | Keys.F5)) this.RunAtCursor()
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.Shift | Keys.X :
this.ToggleExtraSpeech()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.Shift | Keys.X :
this.ToggleExtraKeys()
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.D :
this.DeleteLine()
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.F :
this.FindText(false)
oArgs.SuppressKeyPress = true
break
case Keys.F3 :
this.FindText(true)
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.I :
this.Import()
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.E :
this.Export()
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.OemQuestion :
LbcMdiApp.Instance.CommandLineDirectory()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.OemQuestion :
LbcMdiApp.Instance.ExplorerDirectory()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.Z :
this.SayStatus()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.F1 :
this.AboutBox()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.Shift | Keys.C :
this.ConfigurationOptions()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.Shift | Keys.M :
this.ManualOptions()
oArgs.SuppressKeyPress = true
break
case Keys.F1 :
this.Documentation()
oArgs.SuppressKeyPress = true
break
case Keys.Shift | Keys.F1 :
this.FocusTip()
oArgs.SuppressKeyPress = true
break
case Keys.F4 :
LbcMdiFrame.Instance.PickWindow()
oArgs.SuppressKeyPress = true
break
case Keys.Shift | Keys.F4 :
LbcMdiFrame.Instance.SayWindows()
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.F10 :
this.ControlMenu()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.F10 :
this.AlternateMenu()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.Shift | Keys.F10 :
this.ScriptMenu()
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.F11 :
this.SetMessage('Arrange Icons')
this.LayoutMdi(MdiLayout.ArrangeIcons);
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.F11 :
this.SetMessage('Cascade')
this.LayoutMdi(MdiLayout.Cascade);
oArgs.SuppressKeyPress = true
break
case Keys.Control | Keys.Shift | Keys.F11 :
this.SetMessage('Tile Horizontal')
this.LayoutMdi(MdiLayout.TileHorizontal);
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.Shift | Keys.F11 :
this.SetMessage('Tile Vertical')
this.LayoutMdi(MdiLayout.TileVertical);
oArgs.SuppressKeyPress = true
break
case Keys.Alt | Keys.OemQuotes :
this.SayClipboard()
oArgs.SuppressKeyPress = true
break
// Does not work
// Default :
// return
} // switch
} // HandleKeyDown method

function HandleLoad(oSender:Object, oArgs:EventArgs) {
// Handler for Load event

var sEvent = 'Load'
var bHandler = false
// This fails to stop the no object reference crash
if (this && this != null && this.Handler) {
try {
bHandler = (typeof(eval(this.Handler, 'unsafe')) == 'function')
}
catch (e) {}
} // if

return
var bResult = false
if (bHandler) {
try {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
catch (e) {}
}
if (bResult) return

} // HandleLoadEvent method

function HandleLostFocus(oSender:Object, oArgs:EventArgs) {
// Handler for LostFocus event of a control

var sEvent = 'LostFocus'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return

var sName = Lbc.GetName(oSender)
if (sName.StartsWith('Memo_')) this.AcceptButton = this.LastAcceptButton
} // HandleLostFocusEvent method

function HandlePaint(oSender:Object, oArgs:PaintEventArgs) {
// Handler for Paint event

var sEvent = 'Paint'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return

var sName = Lbc.GetName(oSender)
// Acc.Say(sName)
if (sName.StartsWith('TextBox_')) {
var txt:TextBox = oSender
var iIndex = txt.SelectionStart + txt.SelectionLength
var iLine = txt.GetLineFromCharIndex(iIndex) + 1
var iColumn = iIndex - txt.GetFirstCharIndexOfCurrentLine() + 1
var iLength = txt.TextLength
var nPercent: Double = 0
if (iLength > 0) nPercent = System.Math.Round(100.0 * iIndex/ iLength, 1)
var sText = 'Line ' + iLine + '   ' + 'Column ' + iColumn + '   ' + 'Percent ' + nPercent
this.SetStatus(sText)
// Acc.Say(sText)
return
} // if TextBox

for (var oMenu: ToolStripMenuItem in this.MainMenuStrip.Items) {
// for (var oItem: ToolStripMenuItem in oMenu.DropDownItems) {
for (var o in oMenu.DropDownItems) {
if (!o.GetType().ToString().EndsWith('MenuItem')) continue
var oItem: ToolStripMenuItem = o
if (!oItem) continue
if (!oItem.Selected) continue
var sName = oItem.Name
var sTip = this.FocusTips[sName]
this.SetStatus(sTip)
break
} // j
} // i
} // HandlePaintEvent method

function HandleProgressChanged(oSender:Object, oArgs:ProgressChangedEventArgs) {
// Handler for ProgressChanged event

var sEvent = 'ProgressChanged'
// var sCode = this.Handler + '(sEvent, oSender, oArgs)'
// eval(sCode, 'unsafe')
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
} // HandleProgressChangedEvent method

function HandleRunWorkerCompleted(oSender:Object, oArgs:RunWorkerCompletedEventArgs) {
// Handler for RunWorkerCompleted event

var sEvent = 'RunWorkerCompleted'
// var sCode = this.Handler + '(sEvent, oSender, oArgs)'
// eval(sCode, 'unsafe')
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
} // HandleRunWorkerCompletedEvent method

function HandleSelectedIndexChanged(oSender:Object, oArgs:EventArgs) {
// Handler for SelectedIndexChanged event of a ListBox

var sEvent = 'SelectedIndexChanged'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
} // HandleSelectedIndexChangedEvent method

function HandleSelectionChanged(oSender:Object, oArgs:EventArgs) {
// Handler for SelectionChanged event of a RichTextBox

var sEvent = 'SelectionChanged'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return

var rtb:RichTextBox = oSender
var iIndex = rtb.SelectionStart + rtb.SelectionLength
var iLine = rtb.GetLineFromCharIndex(iIndex) + 1
var iColumn = iIndex - rtb.GetFirstCharIndexOfCurrentLine() + 1
var iLength = rtb.TextLength
var nPercent: Double = 0
if (iLength > 0) nPercent = System.Math.Round(100.0 * iIndex/ iLength, 1)
var sText = 'Line ' + iLine + '   ' + 'Column ' + iColumn + '   ' + 'Percent ' + nPercent
this.SetStatus(sText)
} // HandleSelectionChangedEvent method

function HandleShown(oSender:Object, oArgs:EventArgs) {
// Handle for Shown event of a dialog

var sEvent = 'Shown'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
try {
bResult = eval(sCode, 'unsafe')
}
catch (e) {}
}
if (bResult) return
} // HandleShownEvent method

function HandleTick(oSender:Object, oArgs:EventArgs) {
// Handler for Tick event

var sEvent = 'Tick'
// var sCode = this.Handler + '(sEvent, oSender, oArgs)'
// eval(sCode, 'unsafe')
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return
} // HandleTickEvent method

function HandleTypeValidationCompleted(oSender:Object, oArgs:TypeValidationEventArgs) {
// Handler for Validating event of a dialog

var sEvent = 'TypeValidationCompleted'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return

// Acc.Say(sEvent)
// Acc.Say('return value ' + oArgs.ReturnValue)

// Acc.Say('CancelButtonClicked ' + this.CancelButtonClicked)
// Does not work because this event occurs before Cancel click event
if (this.CancelButtonClicked) return

if (oArgs.IsValidInput) oSender.Text = oArgs.ReturnValue.ToString()
else {
var sMessage = 'Invalid input!\r\n'
var sTip = Lbc.GetTip(oSender)
if (sTip) sMessage = sMessage + 'Focus tip:  ' + sTip + '\r\n'
sMessage = sMessage + '\r\nContinue input?'
if (Lbc.DialogConfirm('Confirm', sMessage, 'Y') == 'N') this.Close()
else oArgs.Cancel = true
}
} // HandleTypeValidationCompleted method

function HandleValidating(oSender:Object, oArgs:CancelEventArgs) {
// Handler for Validating event of a dialog

var sEvent = 'Validating'
var bHandler = false
try {
if (typeof(eval(this.Handler, 'unsafe')) == 'function') bHandler = true
}
catch (e) {}

var bResult = false
if (bHandler) {
var sCode = this.Handler + '(sEvent, oSender, oArgs)'
bResult = eval(sCode, 'unsafe')
}
if (bResult) return

// Acc.Say('Validating')
} // HandleValidating method

function Import() {
var sFile: String = Lbc.DialogOpenFile('Open')
if (!sFile) return

return this.Import(sFile)
} // Import method

function Import(sFile: String) {
// Import data from a file into controls of the current dialog

var oDoc = Jax.XmlOpenFile(sFile)
// Acc.Say(Jax.VtTypeName(oDoc))
var sName = 'Form_' + this.Text
sName = sName.Replace('&', '').Replace(' ', '_')
var oNodes = oDoc.selectNodes('Root/' + sName + '/*')
var oNodes = oDoc.selectNodes('Root/' + sName + '/*')
// Acc.Say(oNodes.length)
for (var i = 0; i < oNodes.length; i++) {
var oNode = oNodes.item(i)
var sName = oNode.nodeName
// Acc.Say(sName)
if (sName.StartsWith('MenuItem_')) continue
var ctl = this.Widgets[sName]
if (!ctl) continue

var sText = oNode.text
if (ctl.Items) {
var aLines = sText.split('\n')
ctl.Items.Clear()
for (var j = 0; j < aLines.length; j++) ctl.Items.Add(aLines[j], j)
if (ctl.Items.Count) ctl.SelectedIndex = 0
}
else ctl.Text = sText
} // i

oNodes = null
} // Import method

// private function Init(sTitle: String) {
function Init(sTitle: String) {
var sHandler = ''
var dFocusTips = new Hashtable()
return Init(sTitle, sHandler, dFocusTips)
} // Init method

// private function Init(sTitle: String, sHandler: String) {
function Init(sTitle: String, sHandler: String) {
var dFocusTips = new Hashtable()
return Init(sTitle, sHandler, dFocusTips)
} // Init method

function Init(sTitle: String, sHandler: String, dFocusTips: Hashtable) {
// Initialize an LbcForm

this.SuspendLayout()
if (!sTitle) var sTitle = ''
if (!sHandler) var sHandler = null
if (!dFocusTips) var dFocusTips = new Hashtable()
// for (var sKey in dFocusTips) Lbc.DialogShow(sKey, dFocusTips[sKey])
this.Text = sTitle
if (sHandler) this.Handler = sHandler
if (dFocusTips) this.FocusTips = dFocusTips
// Lbc.DialogShow(this.FocusTips.GetType(), typeof(this.FocusTips))
// for (var sKey in this.FocusTips) Lbc.DialogShow(sKey, this.FocusTips[sKey])

// if (this.IsDialog) this.Owner = Form.ActiveForm
this.MainMenuStrip = CreateMainMenu()
// this.Controls.Add(this.MainMenuStrip)
this.MainPanel = CreateVerticalPanel()
this.MainPanel.Dock = DockStyle.Fill
this.Controls.Add(this.MainPanel)
this.AddBand()
} // Init method

function FindText(bAgain: Boolean) {
var sJump = this.LastFocusJump
if (!sJump) bAgain = false

if (!bAgain) {
sJump = Lbc.DialogInput('Find', 'Text', sJump)
if (!sJump) return
}

if (sJump == this.LastFocusJump) bAgain = true
else this.LastFocusJump = sJump

var aItems = this.GetWidgets()
var iFocus = -1
for (var iCtl = 0; iCtl < aItems.length; iCtl++) {
var ctl = aItems[iCtl]
if (ctl.Focused) {
iFocus = iCtl
break
}
}

// Acc.Say('iFocus ' + iFocus)
if (iFocus == -1) iFocus = 0
for (var j = 0; j < 2; j++ ) {

var i = -1
var iLength = aItems.length
// Acc.Say('j ' + j)
i = iFocus
while (true) {
iLength --
if (iLength == -1) break

i++

if (i == aItems.length) i = 0
// Acc.Say('i ' + i)

var ctl = aItems[i]

var sClass: String = Lbc.GetClass(ctl)
// Acc.Say(sClass)
if (!ctl.CanFocus) continue

// if (sClass == 'ListBox') {
if (ctl.Items) {
var iStart = ctl.SelectedIndex
if (bAgain) iStart++
// if (i != iFocus && iStart == ctl.Items.Count) iStart = -1
if (j == 1) iStart = 0
if (iStart == -1) iStart = 0

// Acc.Say('iStart ' + iStart)
for (var iIndex = iStart; iIndex < ctl.Items.Count; iIndex++) {
// Acc.Say('iIndex ' + iIndex)
if (!ctl.Items(iIndex).ToString().ToLower().Contains(sJump.ToLower())) continue
// Acc.Say('item found')
ctl.Focus()
ctl.SelectedIndex = iIndex
this.SetMessage('Found!')
return
} // for iIndex
} // ListBox

if (!ctl.Text) continue

if (sClass.IndexOf('TextBox') >= 0) {
var iStart = ctl.SelectionStart + ctl.SelectionLength
if (bAgain) iStart++
if (j == 1) iStart = 0
// Acc.Say('iStart ' + iStart)
if (iStart >= ctl.TextLength) var iIndex = -1
else var iIndex = ctl.Text.ToLower().IndexOf(sJump.ToLower(), iStart)
if (iIndex == -1) continue

// Acc.Say('text found')
ctl.Focus()
ctl.SelectionStart = iIndex
ctl.SelectionLength = 0
this.SetMessage('Found!')
return
} // if TextBox

// if (j == 0 && bAgain && i == iFocus) continue

if (!ctl.Text.ToLower().Contains(sJump.ToLower())) continue
if (!ctl.AccessibleName.ToLower().Contains(sJump.ToLower())) continue
if (sClass == 'Label') ctl = aItems[i + 1]
ctl.Focus()
this.SetMessage('Found!')
return
} // i
} // j

this.AddMessage('Not found!')
} // FindText method

function ToggleKeyDescriber() {
if (this.KeyDescriber) {
this.AddMessage('No Key Describer')
this.KeyDescriber = false
}
else {
this.AddMessage('Key Describer On')
this.KeyDescriber = true
} // if KeyDescriber
} // ToggleKeyDescriber method

function LbcForm() {
// Instantiate an LbcForm

// Causes double initialization from C# or VBNET
// this(null, null, null)
} // LbcForm parameterless constructor

function LbcForm(sTitle: String) {
// Instantiate an LbcForm, passing a value for its title
var sHandler = 'OnEvent'
var dFocusTips = new Hashtable()
this.Init(sTitle, sHandler, dFocusTips)
} // LbcForm constructor

function LbcForm(sTitle: String, sHandler: String) {
// Instantiate an LbcForm, passing values for its title and event handler

var dFocusTips = new Hashtable()
this.Init(sTitle, sHandler, dFocusTips)
} // LbcForm constructor

function LbcForm(sTitle: String, sHandler: String, dFocusTips: Hashtable) {
// Instantiate an LbcForm, passing values for its title, event handler, and status messages

this.Init(sTitle, sHandler, dFocusTips)
} // LbcForm constructor

function FocusTip() {
var sName = this.GetFocusName()
var sTip = this.FocusTips[sName]
var sText = ''
// for (var o in this.FocusTips) sText += o.Key + '=' + o.Value + '\r\n'
// Lbc.DialogShow('Tips', sText)
this.AddMessage(sTip)
} // FocusTip method

function SayClipboard() {
// Say clipboard text

var sText: String = Clipboard.GetText()
this.SetMessage(sText)
} // SayClipboard method

function ScriptMenu() {
var sPath = LbcMdiApp.Instance.ScriptDir
var oApp = LbcMdiApp.Instance
// Causes return value of DialogPick to be converted to the 'null' string rather than null value
// var sFile: String = sPath
var sFile = sPath
if (Directory.Exists(sPath)) {
var aValues = Directory.GetFiles(sPath, '*.js')
var aNames = new Array(aValues.Length)
for (var i = 0; i < aValues.Length; i++) {
var sValue = aValues[i]
var sName = Path.GetFileNameWithoutExtension(sValue)
aNames[i] = sName
}

sFile = Lbc.DialogPick("Pick Script", "", aNames, aValues)
if (!sFile) return
} // if Directory.Exists

var sCode = File.ReadAllText(sFile)
return Lbc.ExecuteScript(sCode,oApp)
} // ScriptMenu method

function SetFocusTips(sFile: String, sSection: String) {
var aNames = Ini.ReadKeys(sFile, sSection)
for (var i = 0; i < aNames.length; i++) {
var sName = aNames[i]
var sValue = Ini.ReadValue(sFile, sSection, sName)
this.FocusTips[sName] = sValue
} // for
} // SetFocusTips method

function SetCommandName(sText: String) {
if (System.Array.IndexOf(this.SuppressedCommandNames, sText) >= 0) {} // Do nothing
else if (System.Array.IndexOf(this.SpeechOnlyCommandNames, sText) >= 0) Acc.Say(sText)
else if (System.Array.IndexOf(this.StatusOnlyCommandNames, sText) >= 0) this.SetStatus(sText)
else this.SetMessage(sText)
} // SetCommandName method

function AddCommandName(sText: String) {
if (System.Array.IndexOf(this.SuppressedCommandNames, sText) >= 0) {} // Do nothing
else if (System.Array.IndexOf(this.SpeechOnlyCommandNames, sText) >= 0) Acc.Say(sText)
else if (System.Array.IndexOf(this.StatusOnlyCommandNames, sText) >= 0) this.AddStatus(sText)
else this.AddMessage(sText)
} // AddCommandName method

function SetMessage(sText: String) {
Acc.Say(sText)
SetStatus(sText)
} // SetMessage method

function AddMessage(sText: String) {
Acc.Say(sText)
AddStatus(sText)
} // AddMessage method

function SayStatus() {
// Say status line

var sText: String = this.GetStatus()
Acc.Say(sText)
} // SayStatus method

function SetStatus(sText: String) {
// Set status text

var sStatus = this.GetStatus().Trim()
if (sStatus && sStatus != 'Status') this.LastStatus = sStatus
// Acc.Say('LastStatus ' + this.LastStatus)

var frame: LbcForm = Form.ActiveForm
var child: LbcForm = null
if (frame) child = frame.ActiveMdiChild
var frm : LbcForm = this.Owner

if (frame && frame.Handle != this.Handle) frame.ClearStatus()
if (child && child.Handle != this.Handle) child.ClearStatus()
if (frm && frm.Handle != this.Handle) frm.ClearStatus()

var sb:StatusStrip = this.Controls['StatusBar']
var lbl = sb.Items(0)
lbl.Text = sText
return this.LastStatus
} // SetStatus method

function ToggleExtraKeys() {
if (this.ExtraKeys) this.SetMessage('No Extra Keys')
else this.SetMessage('Extra Keys On')
this.ExtraKeys = !this.ExtraKeys
} // ToggleExtraKeys method

function ToggleExtraSpeech() {
var bOldExtraSpeech = Acc.ExtraSpeech
Acc.ExtraSpeech = true
if (bOldExtraSpeech) this.SetMessage('No Extra Speech')
else this.SetMessage('Extra Speech On')
Acc.ExtraSpeech = !bOldExtraSpeech
} // ToggleExtraSpeech method

function RunAtCursor() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

if (txt.SelectionLength == 0) {
var sTitle = 'Run Line at Cursor'
var iIndex: Int32 = txt.SelectionStart + txt.SelectionLength
var iRow: Int32 = txt.GetLineFromCharIndex(iIndex)
var iStart: Int32 = txt.GetFirstCharIndexFromLine(iRow)
var iEnd: Int32 = txt.GetFirstCharIndexFromLine(iRow + 1)
if (iEnd <= 0) iEnd = txt.TextLength
else iEnd --
var iLength: Int32 = iEnd - iStart
var sText: String = txt.Text.Substring(iStart, iLength)
}
else {
var sTitle = 'Run Selected at Cursor'
var sText = txt.SelectedText
}

var sLabel = 'Path'
var sReplace = ''
var sMatch = '(\r|\n)'
sText = Jax.RegExpReplace(sText, sMatch, sReplace)
sMatch = '^(\\<| )+'
sText = Jax.RegExpReplace(sText, sMatch, sReplace)
sMatch = '(\\>| |\\.)+$'
sText = Jax.RegExpReplace(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

var sResult = Lbc.DialogInput(sTitle, sLabel, sText).Trim()
if (sResult.Length == 0) return
Process.Start(sResult)

} // RunAtCursor method
function SayYield() {
var txt = this.GetFocusControl()
var sName = txt.Name
if (!sName.StartsWith('TextBox_') && !sName.StartsWith('MaskedTextBox_') && !sName.StartsWith('Memo_')) return

var iStart = txt.SelectionStart
var iEnd = iStart + txt.SelectionLength
if (iStart == iEnd) {
this.AddMessage('All')
iStart = 0
iEnd = txt.TextLength
}
else  this.AddMessage('Selected')

var sText = txt.Text.Substring(iStart, iEnd - iStart)
var iResult = sText.Length
this.AddMessage(Jax.StringPlural('character', iResult))

if (iResult > 0) {
iResult = Jax.RegExpCount(sText, '\\S+')
this.AddMessage(Jax.StringPlural('Word', iResult))
iResult = Jax.RegExpCount(sText, '\n') + 1
this.AddMessage(Jax.StringPlural('Line', iResult))
}


} // SayYield method

} // LbcForm class

class LbcProgressBarWindow extends LbcForm {
function LbcProgressBarWindow() {
// Must call constructor on first line
/*
var sTitle = 'Progress Bar'
var iMinValue = 0
var iMaxValue = 100
var iStep = 1
var dTips = new Hashtable()
this(sTitle, iMinValue, iMaxValue, iStep, dTips)
*/
this(null, null, null, null, null)
} // LbcProgressBarWindow constructor

function LbcProgressBarWindow(sTitle: String, iMinValue: Int32, iMaxValue: Int32, iStep: Int32) {
this(sTitle, iMinValue, iMaxValue, iStep, null)
} // LbcProgressBarWindow constructor

function LbcProgressBarWindow(sTitle: String, iMinValue: Int32, iMaxValue: Int32, iStep: Int32, dTips: Hashtable) {

if (!sTitle) var sTitle = 'Progress Bar'
if (!iMinValue) var iMinValue = 0
if (!iMaxValue) var iMaxValue = 100
if (!iStep) var iStep = 1
if (!dTips) var dTips = new Hashtable()
var sTip = ''

this.Init(sTitle, 'this.HandleProgressBarWindow', null)
var pb:ProgressBar = this.AddProgressBar(iMinValue, iMaxValue, iStep, sTip)
this.CompleteWindow(['Close'], null)
} // ProgressBarWindow constructor

function HandleProgressBarWindow(sEvent: String, oSender, oArgs) {
// Custom event handler for ProgressBarWindow

switch (sEvent) {
case 'Shown' :
this.Result = true
return
case 'Click' :
switch(oSender.Name) {
case 'Button_Close' :
// this.Dispose()
this.Result = false
this.Close()
return
} // oSender.Name
} // sEvent
} // HandleProgressBarWindow method

function GetValue():Decimal {
var pb = this.Widgets['ProgressBar_']
return pb.Value
} // GetValue method

function SetValue(nValue) {
var pb = this.Widgets['ProgressBar_']
pb.Value = nValue
} // SetValue method

function Step() {
var pb = this.Widgets['ProgressBar_']
pb.PerformStep()
} // Step method
} // LbcProgressBarWindow class

class YesNo {
var Yes:Boolean = false

static function Parse(sText: String): YesNo {
var o: YesNo = new YesNo()
var sText = sText.Trim().ToLower()
if (sText == 'y') o.Yes = true
else if (sText == 'n') o.Yes = false
else throw new ArgumentException(' Enter y for Yes or n for No')
return o
} // Parse method

override function ToString(): String {
if (this.Yes) return 'y'
else return 'n'
} // ToString method
} // YesNo class

class LbcMdiApp extends Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase {

public static var Instance: LbcMdiApp
// Define properties of the class, enabling global references to certain objects and data
// This property and similar ones must be defined in derived class
/*
public static var App: LbcMdiApp

static LbcMdiApp {
} // static constructor

public var Frame: LbcMdiFrame

public function get Child(): LbcMdiChild {
return this.Frame.ActiveMdiChild
}

function set Child(value: LbcMdiChild) {
value.Activate()
}
*/

var CommandLineHistory: ArrayList
var ExecutableName: String
var ProgramName: String
var ProgramDir: String
var HelpDir: String
var DataDir: String
var ScriptDir: String
var HelpFile: String
var DefaultIniFile: String
var IniFile: String
var LogFile: String
var TempFile: String
var TempFiles: ArrayList

function GetDirChoice() {
var sDir: String = Directory.GetCurrentDirectory()
var sName = Path.GetFileNameWithoutExtension(sDir)
if (!sName) sName = '\\'
var aButtons = ['Current (' + sName + ')', 'Program', 'Data', 'Script', 'Other']
var sButton: String = Lbc.DialogChoose('Choose Directory', '', aButtons)
if (!sButton) return

switch (sButton) {
case 'Current' :
break
case 'Program' :
sDir = this.ProgramDir
break
case 'Data' :
sDir = this.DataDir
break
case 'Script' :
sDir = this.ScriptDir
break
case 'Other' :
sDir = Lbc.DialogOpenFolder('Open Folder', sDir)
if (!sDir) return
break
} // switch
return sDir
} // GetDirChoice method

function CommandLineDirectory() {
var sDir = GetDirChoice()
if (!sDir) return

Directory.SetCurrentDirectory(sDir)
var sCommand: String = '%COMSPEC% /k cd "' + sDir + '"'
Jax.ShellRun(sCommand, 1, false)
} // CommandLineDirectory method

function ExplorerDirectory() {
var sDir = GetDirChoice()
if (!sDir) return

Directory.SetCurrentDirectory(sDir)
Process.Start(sDir)
} // ExplorerDirectory method

function Init() {
LbcMdiApp.Instance = this
var sExe: String = Application.ExecutablePath
this.ExecutableName = Path.GetFileNameWithoutExtension(sExe)
this.ProgramName = Application.ProductName
this.ProgramDir = Application.StartupPath
this.HelpDir = Path.Combine(this.ProgramDir, 'Help')
if (!Directory.Exists(this.HelpDir)) this.HelpDir = this.ProgramDir
this.HelpFile = Path.Combine(this.HelpDir, this.ExecutableName + '.htm')

var sDir: String = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)
this.DataDir = Path.Combine(sDir, this.ProgramName)
if (!Directory.Exists(this.DataDir)) this.DataDir = this.ProgramDir
this.ScriptDir = Path.Combine(this.DataDir, 'Scripts')
if (!Directory.Exists(this.ScriptDir)) this.ScriptDir = this.DataDir
this.DefaultIniFile = Path.Combine(this.ProgramDir, this.ExecutableName + '.ini')
this.IniFile = Path.Combine(this.DataDir, this.ExecutableName + '.ini')
Ini.Init(this.DefaultIniFile, IniFile, 'Configuration')
this.LogFile = Path.Combine(this.DataDir, this.ExecutableName + '.log')
this.TempFile = Path.Combine(this.DataDir, this.ExecutableName + '.tmp')
this.TempFiles = new ArrayList()
} // Init method
} // LbcMdiApp class

class LbcMdiFrame extends LbcForm {
static var Instance: LbcMdiFrame

function SayWindows() {
var aChildren = LbcMdiFrame.Instance.MdiChildren
var iLength = aChildren.length
this.AddMessage(iLength)
for (var i = 0; i < iLength; i++) {
var frm: LbcMdiChild = aChildren[i]
var sName = frm.Text
this.AddMessage(sName)
} // for
} // SayWindows method

function PickWindow() {
var aChildren = LbcMdiFrame.Instance.MdiChildren
var aNames = []
var aValues = []
for (var i = 0; i < aChildren.length; i++) {
var frm: LbcMdiChild = aChildren[i]
var sName = frm.Text
aNames.push(sName)
aValues.push(frm)
} // for

var o = Lbc.DialogPick('Pick Window', '', aNames, aValues, true)
if (!o) return

frm = o
frm.Activate()
} // PickWindow method

function LayoutChildren(sType: String) {
var sType = sType.Replace(' ', '')
var sExp = 'MdiLayout.' + sType
var iType = eval(sExp, 'unsafe')
this.LayoutMdi(iType)
/*
ArrangeIcons
Cascade
TileHorizontal
TileVertical
*/
} // LayoutChildren method

override function Init(sTitle: String) {
var sHandler: String = ''
var dFocusTips: Hashtable = new Hashtable()
return this.Init(sTitle, sHandler, dFocusTips)
} // Init method

override function Init(sTitle: String, sHandler: String) {
var dFocusTips: Hashtable = new Hashtable()
return this.Init(sTitle, sHandler, dFocusTips)
} // Init method

override function Init(sTitle: String, sHandler: String, dFocusTips: Hashtable) {
LbcMdiFrame.Instance = this
// Does not work
// LbcMdiApp.Instance.MainForm = this
this.IsMdiContainer = true
super.Init(sTitle, sHandler, dFocusTips)
} // Init method
} // LbcMdiFrame class

class LbcMdiChild extends LbcForm {

override function Init(sTitle: String) {
var sHandler: String = ''
var dFocusTips: Hashtable = new Hashtable()
return this.Init(sTitle, sHandler, dFocusTips)
} // Init method

override function Init(sTitle: String, sHandler: String) {
var dFocusTips: Hashtable = new Hashtable()
return this.Init(sTitle, sHandler, dFocusTips)
} // Init method

override function Init(sTitle: String, sHandler: String, dFocusTips: Hashtable) {
this.MdiParent = LbcMdiFrame.Instance
super.Init(sTitle, sHandler, dFocusTips)
} // Init method
} // LbcMdiChild class
} // Homer package