/// <summary>
/// IGenForm GetForm(int index)
/// Get the form specified by the index
/// </summary>
/// <returns></returns>
public IGenForm GetForm(int index)
{
IGenForm _form = new IGenForm();
try
{
if (index >= 0 && index < forms.Count)
{
_form = forms[index];
}
}
catch (Exception ex)
{
CommonRoutines.DisplayErrorMessage("$E:" + moduleName + ".GetForm(i) > " + ex.Message);
}
return _form;
}
/// <summary>
/// IGenForm GetForm(string formName)
/// Get the form specified by the form name
/// </summary>
/// <returns></returns>
public IGenForm GetForm(string formName)
{
IGenForm _form = new IGenForm();
try
{
for (int n = 0; n < forms.Count; n++)
{
if (formName.ToUpper() == forms[n].name.ToUpper())
{
_form = forms[n];
break;
}
}
}
catch (Exception ex)
{
CommonRoutines.DisplayErrorMessage("$E:" + moduleName + ".GetForm(s) > " + ex.Message);
}
return _form;
}
public int CompileFormValues(string useSchema)
{
int _numFields = 0;
bool _fieldReferencesResolved = true;
int _startIndex = 0;
int _endIndex = 0;
string _sql = "";
string _tableName = "";
string _schema = "";
IGenForm _form = new IGenForm();
IGenField _field = new IGenField();
string _useSchema = useSchema.Trim();
try
{
compileErrors = false;
compileErrorsMessages.Clear();
if (_useSchema.ToUpper() == "<DEFAULT>" || _useSchema == "")
{
_useSchema = "dbo";
}
CommonRoutines.compileErrors.Items.Clear();
DisplayProgress(0, 0);
int _totalFieldsToCompile = 0;
int _fieldToCompile = 0;
CommonRoutines.compileErrors.Items.Add("Compiling...");
sql = "";
#region [Resolve Datasets]
DisplayStatus("Resolving datasets...");
foreach (IGenDataset _ds in datasets)
{
if (_ds.sql != "")
{
// is this a WSTF table reference or a vw_WSTF view reference?
string _overrideSchema = ConfigRoutines.GetSetting("OverrideSchema").ToUpper();
if (_overrideSchema.IndexOf('T') == 0)
{
_sql = _ds.sql;
// get the table/view specified
int _fromOffset = _sql.ToUpper().IndexOf(" FROM ");
if (_fromOffset > 0)
{
// is there a where clause?
int _whereOffset = _sql.ToUpper().IndexOf(" WHERE ", _fromOffset);
if (_whereOffset > 0)
{
_tableName = _sql.Substring(_fromOffset, _whereOffset - _fromOffset).Trim();
// set a marker
_sql = _sql.Substring(0, _fromOffset + 6) + "^" + _sql.Substring(_whereOffset);
}
else
{
_tableName = _sql.Substring(_fromOffset);
_sql = _sql.Substring(0, _fromOffset + 6) + "^";
}
_tableName = _tableName.Substring(5).Trim();
// is there a prefix on it?
int _lastPeriod = _tableName.LastIndexOf('.');
if (_lastPeriod > 0)
{
_schema = _tableName.Substring(0, _lastPeriod);
if (_schema.ToUpper() == "DBO")
{
_tableName = _tableName.Substring(_lastPeriod + 1);
_schema = _useSchema;
}
else
{
_schema = "";
}
}
else
{
if (_tableName.ToUpper().IndexOf("WSTF") >= 0)
{
_schema = _useSchema;
}
}
if (_schema != "")
{
if (_tableName.ToUpper().IndexOf("WSTF") >= 0)
{
_tableName = "[" + _useSchema + "]." + _tableName;
}
}
// replace the table
_sql = _sql.Replace("^", _tableName).Replace("..", ".");
_ds.sql = _sql;
}
}
// get the fields from the sql
string[] _fieldNames = DatabaseRoutines.GetSQLFields(_ds.sql);
_ds.fieldNames = _fieldNames;
// get a count of the rows this will find
_ds.numRows = _ds.GetRowCount();
}
}
#endregion
#region [Compiling forms]
DisplayStatus("Compiling forms...");
// reset the forms with the original values
for (int n = 0; n < forms.Count; n++)
{
_form = forms[n];
_totalFieldsToCompile = _totalFieldsToCompile + _form.formFields.fields.Count;
_form.datasets.Clear();
// for each of the datasetordinals, create a dataset entry
for (int m = 0; m < _form.datasetOrdinals.Count; m++)
{
int _dsOrdinal = _form.datasetOrdinals[m];
if (_dsOrdinal < 0)
{
break;
}
if (m == 0)
{
_form.datasetOrdinal = _dsOrdinal;
_form.dataset = datasets[_dsOrdinal];
}
// clone a dataset
IGenDataset _formDataset = datasets[_dsOrdinal].Clone();
_formDataset.referenceDatasetOrdinal = _dsOrdinal;
_form.datasets.Add(_formDataset);
}
// set the page collection
if (_form.datasetOrdinal >= 0)
{
_form.DeterminePages();
}
for (int m = 0; m < _form.formFields.fields.Count; m++)
{
// put here to fix the first textbox not retaining entered values
_field = _form.formFields.fields[m];
switch (_field.type.ToUpper())
{
case "TEXTBOX":
case "COMBOBOX":
case "CHECKBOX":
break;
default:
_field.compiledValue = _field.originalValue;
_field.value = _field.originalValue;
_field.text = "";
_form.formFields.fields[m] = _field;
break;
}
}
}
#endregion
bool _needsResolving = true;
while (_needsResolving)
{
_fieldReferencesResolved = true;
_needsResolving = false;
for (int n = 0; n < forms.Count; n++)
{
_form = forms[n];
// for each field, resolve any [field] references to their {formnumber:fieldnumber}
for (int m = 0; m < _form.formFields.fields.Count; m++)
{
// get the value
_field = _form.formFields.fields[m];
_fieldToCompile = _fieldToCompile + 1;
DisplayProgress(_fieldToCompile, _totalFieldsToCompile);
string _value = _field.compiledValue;
string _compiledValue = _value;
string _fieldName = _field.name;
if (_value.Trim() != "" && _field.type.ToUpper() != "TEXTBOX")
{
// now loop until no more fields references are found
_needsResolving = true;
DisplayStatus("Resolving field " + _field.name + ", value=" + _value);
while (_needsResolving)
{
_needsResolving = false;
bool _keepChecking = true;
#region [Functions]
// check for functions that need expanding
if (_value.ToUpper().IndexOf("=SUM(") >= 0 || _value.IndexOf("=ADD(") >= 0 ||
_value.ToUpper().IndexOf("=SUBTRACT(") >= 0 || _value.IndexOf("=SUB(") >= 0 ||
_value.ToUpper().IndexOf("=MULTIPLY(") >= 0 || _value.IndexOf("=MULT(") >= 0 ||
_value.ToUpper().IndexOf("=DIVIDE(") >= 0 || _value.IndexOf("=DIV(") >= 0)
{
_needsResolving = true;
// get the start...
int _index = _value.IndexOf('=');
// sum the fields given
_startIndex = _value.IndexOf('(');
_endIndex = _value.IndexOf(')');
string _fields = "";
if (_endIndex <= _startIndex)
{
_needsResolving = false;
compileErrors = true;
compileErrorsMessages.Add(_fieldName + " has missing ending paren: " + _compiledValue);
}
if (_endIndex > _startIndex)
{
_fields = _value.Substring(_startIndex + 1, _endIndex - _startIndex - 1);
if (_fields != "")
{
if (_fields.IndexOf('*') >= 0)
{
// get the list, exclude the field on if it is part of the pattern
_fields = GetFieldNames(forms[n].name, _fieldName, _fields);
// not parse it out and create [field] + [field] + [field] + ...
string[] _parts = _fields.Split('~');
_fields = "";
for (int k = 0; k < _parts.Length; k++)
{
if (_parts[k].Trim() != "")
{
//_fields = _fields + "[" + _parts[k].Trim() + "] + ";
// now determine the operator
if (_value.ToUpper().IndexOf("=SUM(") >= 0 || _value.IndexOf("=ADD(") >= 0)
{
_fields = _fields + "[" + _parts[k].Trim() + "] + ";
}
else
{
if (_value.ToUpper().IndexOf("=SUBTRACT(") >= 0 || _value.IndexOf("=SUB(") >= 0)
{
_fields = _fields + "[" + _parts[k].Trim() + "] - ";
}
else
{
if (_value.ToUpper().IndexOf("=MULTIPLY(") >= 0 || _value.IndexOf("=MULT(") >= 0)
{
_fields = _fields + "[" + _parts[k].Trim() + "] / ";
}
else
{
if (_value.ToUpper().IndexOf("=DIVIDE(") >= 0 || _value.IndexOf("=DIV(") >= 0)
{
_fields = _fields + "[" + _parts[k].Trim() + "] * ";
}
}
}
}
}
}
// get rid of the last +
if (_fields.Length > 0)
{
_fields = _fields.Substring(0, _fields.Length - 2);
}
}
else
{
char _listChar = ' ';
// is there a list (separated by comma)
if (_fields.IndexOf(',') > 0)
{
_listChar = ',';
}
else
{
if (_fields.IndexOf('+') > 0)
{
_listChar = '+';
}
}
if (_listChar != ' ')
{
string[] _fieldList = _fields.Split(_listChar);
if (_fieldList.Length > 1)
{
_fields = "";
for (int j = 0; j < _fieldList.Length; j++)
{
if (_fieldList[j].Trim() != "")
{
_fields = _fields + "[" + _fieldList[j] + "] + ";
}
}
// get rid of the last +
_fields = _fields.Substring(0, _fields.Length - 2);
}
}
else
{
_fields = "[" + _fields + "]";
}
}
// now replace the functional part
if (_index == 0)
{
_value = _fields + _value.Substring(_endIndex + 1);
}
else
{
_value = _value.Substring(0, _index) + _fields + _value.Substring(_endIndex + 1);
}
if (_value.Length > 0)
{
_value = "=" + _value;
}
}
else
{
_value = "";
}
// replace the compiled value
_field = _form.formFields.fields[m];
_field.compiledValue = _value;
_field.text = "";
_form.formFields.fields[m] = _field;
}
}
#endregion
// check for fields
if (_value.IndexOf('[') >= 0)
{
IGenField _tempField = _form.formFields.fields[m];
// resolve the value to it's compiled format
string _tempValue = ResolveFields(_tempField);
_value = _tempValue;
_fieldReferencesResolved = false;
_numFields = _numFields + 1;
_needsResolving = true;
}
#region [Check for GDS(]
// check for GDS columns
if (_value.ToUpper().IndexOf("GDS(") >= 0)
{
if (datasetName != "")
{
// replace the compiled value
_field = _form.formFields.fields[m];
_value = _field.value;
// datasetname here is the default one specified for the form group
_value = ResolveDS(datasetName, _field, _value, "GDS(");
}
else
{
_value = "";
}
_field.compiledValue = _value;
_field.text = "";
_form.formFields.fields[m] = _field;
_keepChecking = false;
}
#endregion [Check for GDS(]
#region [Check for DS(]
if (_value.ToUpper().IndexOf("DS(") >= 0)
{
// replace the compiled value
_field = _form.formFields.fields[m];
//_value = _field.value;
_value = ResolveDS(_form.datasetName, _field, _value, "DS(");
_field.compiledValue = _value;
_field.text = "";
_form.formFields.fields[m] = _field;
_keepChecking = false;
}
#endregion [Check for DS(]
#region [Check for DSLOOKUP(]
if (_value.ToUpper().IndexOf("DSLOOKUP(") >= 0)
{
// syntax: DSLOOKUP(<dsname|dsordinal!>columnname, filter>
// replace the compiled value
_field = _form.formFields.fields[m];
//_value = _field.value;
_value = ResolveDS(_form.datasetName, _field, _value, "DSLOOKUP(");
_field.compiledValue = _value;
_field.text = "";
_form.formFields.fields[m] = _field;
_keepChecking = false;
}
#endregion [Check for DSLOOKUP(]
#region [Check for PAGEBREAK(]
if (_value.ToUpper().IndexOf("PAGEBREAK(") >= 0)
{
// syntax: PAGEBREAK(dsname|dsordinal!, true stmt, false stmt>
// replace the compiled value
_field = _form.formFields.fields[m];
//_value = _field.value;
_value = ResolveDS(_form.datasetName, _field, _value, "PAGEBREAK(");
_field.compiledValue = _value;
_field.text = "";
_form.formFields.fields[m] = _field;
_keepChecking = false;
}
#endregion [Check for PAGEBREAK(]
if (_keepChecking)
{
// regular
#region [No functions found]
// replace the compiled value
_field = _form.formFields.fields[m];
_field.compiledValue = _value;
_field.text = "";
_form.formFields.fields[m] = _field;
#endregion
}
}
}
}
}
}
DisplayStatus("Done!");
DisplayProgress(0, 0);
// were there any errors?
if (compileErrors)
{
DisplayStatus("Compiled with errors.");
CommonRoutines.compileErrors.Items.Add("Compiled with errors");
if (CommonRoutines.compileErrors == null)
{
CommonRoutines.compileErrors = new ListBox();
}
// output the errors
if (compileErrorsMessages.Count > 0)
{
// write out the compile errors.
CommonRoutines.WriteFile(".\\compile_errors.txt", compileErrorsMessages);
for (int n = 0; n < compileErrorsMessages.Count; n++)
{
CommonRoutines.compileErrors.Items.Add(compileErrorsMessages[n]);
}
}
}
CommonRoutines.compileErrors.Items.Add("Done.");
}
catch (Exception ex)
{
CommonRoutines.DisplayErrorMessage("$E:" + moduleName + ".CompileFormValues > " + ex.Message);
}
// output the fields for debugging
OutputFormInfo("CompiledFields.txt");
return _numFields;
}
/// <summary>
/// string LoadFormGroup(string formFile)
/// Load the form group
/// </summary>
/// <returns></returns>
public int CreateForms(List<string> xmlRecords)
{
int _numForms = 0;
string _tagName = "";
string _tagValue = "";
bool _formFlag = false;
bool _fieldFlag = false;
bool _ruleFlag = false;
bool _datasetFlag = false;
IGenForm _form = null;
IGenField _field = null;
IGenDataset _dataset = null;
string _formGroupPath = "";
bool _variableFlag = false;
string _variableName = "";
string _variableValue = "";
try
{
// clear the forms collection
forms.Clear();
// clear the datasets
datasets.Clear();
// walk the XML and create the entities
for (int _recNo=0;_recNo < xmlRecords.Count;_recNo++)
//foreach (string _xmlRecord in xmlRecords)
{
string _xmlRecord = xmlRecords[_recNo];
// parse the string
int _offset = _xmlRecord.IndexOf('=');
if (_offset > 0)
{
_tagName = _xmlRecord.Substring(0, _offset);
_tagValue = _xmlRecord.Substring(_offset + 1);
}
else
{
_tagName = _xmlRecord;
_tagValue = "";
}
_tagName = _tagName.Trim().ToUpper();
_tagValue = _tagValue.Trim();
if (_tagName != "")
{
// process the tag
switch (_tagName)
{
case "FORMGROUPPATH":
_formGroupPath = _tagValue;
break;
case "FORMS":
_formFlag = false;
_fieldFlag = false;
_ruleFlag = false;
_form = null;
break;
case "FORM":
_formFlag = true;
_fieldFlag = false;
_ruleFlag = false;
// create a form object
_form = new IGenForm();
_form.formGroupPath = _formGroupPath;
forms.Add(_form);
break;
case "FIELDS":
_formFlag = false;
_fieldFlag = false;
_ruleFlag = false;
_field = null;
break;
case "FIELD":
_formFlag = false;
_fieldFlag = true;
_ruleFlag = false;
_field = new IGenField();
_field.parentFormName = _form.name;
// add it
_form.AddField(_field);
break;
case "FONT":
break;
case "/FONT":
break;
case "PROPERTIES":
break;
case "/PROPERTIES":
break;
case "RULES":
break;
case "/RULES":
break;
case "RULE":
break;
case "/RULE":
break;
case "VARIABLES":
_variableFlag = true;
break;
case "/VARIABLES":
_variableFlag = false;
break;
case "VARIABLE":
break;
case "/VARIABLE":
// write the variable to the csa properties
if (_variableName != "")
{
formVariables.Add(new string[] { _variableName, _variableValue });
}
break;
case "/FIELD":
_formFlag = false;
_fieldFlag = false;
_ruleFlag = false;
break;
case "/FORM":
_formFlag = false;
_fieldFlag = false;
_ruleFlag = false;
break;
case "/FORMS":
break;
// not the attribute tags
case "GROUP":
formGroupName = _tagValue;
break;
case "VERSION":
formGroupVersion = _tagValue;
break;
case "DATASOURCE":
// see if this datasource is valid by checking the connection pool.
originalDataSource = _tagValue;
dataSource = "";
for (int n = 0; n < DatabaseRoutines.connectionObjects.Count; n++)
{
if (DatabaseRoutines.connectionObjects[n].connectionString.ToUpper() == _tagValue.ToUpper())
{
dataSource = _tagValue;
break;
}
}
// if datasource is blank, default to main connection
if (dataSource == "")
{
dataSource = DatabaseRoutines.MainConnection;
}
break;
case "GROUPDATASET":
datasetName = "";
if (_tagValue != "")
{
_dataset = new IGenDataset();
_dataset.cursorName = formGroupName;
datasetName = formGroupName;
_dataset.sql = _tagValue;
datasets.Add(_dataset);
_dataset = new IGenDataset();
}
break;
case "FORMDATASET":
if (_formFlag)
{
_form.datasetName = "";
if (_tagValue != "")
{
_dataset = new IGenDataset();
_dataset.cursorName = _form.name;
_form.datasetName = _form.name;
_dataset.sql = _tagValue;
datasets.Add(_dataset);
_dataset = new IGenDataset();
}
}
break;
case "DATASET":
_datasetFlag = true;
_dataset = new IGenDataset();
break;
case "/DATASET":
_datasetFlag = false;
// add to the dataset collection
datasets.Add(_dataset);
_dataset = new IGenDataset();
break;
case "SQL":
if (_datasetFlag)
{
_dataset.sql = _tagValue;
}
break;
case "DATASETNAME":
string _datasetName = _tagValue;
int _datasetOrdinal = -1;
// find it in the group datasets collection
for (int n = 0; n < datasets.Count; n++)
{
if (datasets[n].cursorName.ToUpper() == _datasetName.ToUpper())
{
_datasetOrdinal = n;
break;
}
}
if (_formFlag)
{
// add it to the datasetname list for the form
_form.datasetOrdinals.Add(_datasetOrdinal);
_form.datasetNames.Add(_datasetName);
if (_form.datasetName == "")
{
// default name is the first one in the xml list
_form.datasetName = _datasetName;
_form.datasetOrdinal = _datasetOrdinal;
}
}
else
{
datasetName = _datasetName; // for the GDS function
datasetOrdinal = _datasetOrdinal;
}
break;
case "ROWSPERPAGE":
if (_formFlag)
{
int _rowsPerPage = CommonRoutines.ConvertToInt(_tagValue);
// check to see if this is a multipage form
if (_form.multiPageForm.ToUpper() == "TRUE")
{
if (_rowsPerPage < 1)
{
// give an error!
CommonRoutines.DisplayErrorMessage(_form.name + " - Rows per page must be greater than 0 if a multipage form");
}
else
{
_form.rowsPerPages.Add(_rowsPerPage);
if (_form.rowsPerPage < 0)
{
_form.rowsPerPage = _rowsPerPage;
}
}
}
}
break;
case "/SQL":
break;
case "IMAGE":
if (_formFlag)
{
_form.imageName = _tagValue;
}
else
{
if (_fieldFlag)
{
_field.imageName = _tagValue;
}
else
{
}
}
break;
case "COMMENTS":
if (_formFlag)
{
_form.comments = _tagValue;
}
else
{
if (_fieldFlag)
{
_field.comments = _tagValue;
}
else
{
comments = _tagValue;
}
}
break;
case "NAME":
if (_formFlag)
{
_form.name = _tagValue;
}
else
{
if (_fieldFlag)
{
_field.name = _tagValue;
}
else
{
if (_datasetFlag)
{
_dataset.cursorName = _tagValue;
}
else
{
if (_variableFlag)
{
_variableName = _tagValue;
}
}
}
}
break;
case "CREATESYMBOLICS":
if (_datasetFlag)
{
_dataset.createSymbolics = CommonRoutines.ConvertToBool(_tagValue);
}
break;
case "FORMATMASK":
if (_formFlag)
{
}
else
{
if (_fieldFlag)
{
_field.formatMask = _tagValue;
}
}
break;
case "VISIBLE":
if (_formFlag)
{
_form.visible = (_tagValue.ToUpper() == "TRUE") ? true : false;
}
else
{
if (_fieldFlag)
{
_field.visible = (_tagValue.ToUpper() == "TRUE") ? true : false;
}
else
{
}
}
break;
case "FORMTYPE":
if (_formFlag)
{
_form.formType = _tagValue;
}
break;
case "TITLE":
if (_formFlag)
{
_form.title = _tagValue;
}
break;
case "MULTIPAGEFORM":
if (_formFlag)
{
_form.multiPageForm = (_tagValue.ToUpper() == "TRUE") ? "True" : "False";
}
break;
case "PAGEBREAKS":
if (_formFlag)
{
_form.pageBreaks = _tagValue;
}
break;
case "PROCESSINGORDER":
if (_formFlag)
{
_form.processingOrder = CommonRoutines.ConvertToInt(_tagValue);
if (_form.processingOrder == 0)
{
_form.processingOrder = 999;
}
}
break;
case "TYPE":
if (_fieldFlag)
{
_field.type = _tagValue;
}
else
{
}
break;
case "DATATYPE":
if (_fieldFlag)
{
_field.dataType = _tagValue;
}
else
{
}
break;
case "ALIGNMENT":
if (_fieldFlag)
{
_field.alignment = _tagValue;
}
else
{
}
break;
case "TOP":
if (_fieldFlag)
{
_field.top = CommonRoutines.ConvertToInt(_tagValue);
}
else
{
}
break;
case "LEFT":
if (_fieldFlag)
{
_field.left = CommonRoutines.ConvertToInt(_tagValue);
}
else
{
}
break;
case "WIDTH":
if (_fieldFlag)
{
_field.width = CommonRoutines.ConvertToInt(_tagValue);
}
else
{
}
break;
case "HEIGHT":
if (_fieldFlag)
{
_field.height = CommonRoutines.ConvertToInt(_tagValue);
}
else
{
}
break;
case "TAG":
if (_fieldFlag)
{
_field.tag = _tagValue;
}
else
{
}
break;
case "FONTNAME":
if (_fieldFlag)
{
_field.fontName = _tagValue;
}
else
{
}
break;
case "FONTSIZE":
if (_fieldFlag)
{
_field.fontSize = CommonRoutines.ConvertToFloat(_tagValue);
}
else
{
}
break;
case "FONTBOLD":
if (_fieldFlag)
{
_field.fontBold = (_tagValue.ToUpper() == "TRUE") ? true : false; ;
}
else
{
}
break;
case "FONTITALIC":
if (_fieldFlag)
{
_field.fontItalic = (_tagValue.ToUpper() == "TRUE") ? true : false; ;
}
else
{
}
break;
case "FONTUNDERLINE":
if (_fieldFlag)
{
_field.fontUnderline = (_tagValue.ToUpper() == "TRUE") ? true : false; ;
}
else
{
}
break;
case "TABINDEX":
if (_fieldFlag)
{
_field.tabIndex = CommonRoutines.ConvertToInt(_tagValue);
}
else
{
}
break;
case "LIST":
if (_fieldFlag)
{
_field.list = _tagValue;
}
else
{
}
break;
case "VALUE":
if (_fieldFlag)
{
// if it is not an expression
if (_tagValue.IndexOf('=') < 0)
{
if (_field.type.ToUpper().IndexOf("CHECKBOX") >= 0)
{
bool _checkValue = CommonRoutines.ConvertToBool(_tagValue);
_field.value = _checkValue.ToString();
_field.checkedFlag = _checkValue;
}
}
else
{
_field.value = _tagValue;
}
_field.originalValue = _field.value;
_field.compiledValue = _field.value;
}
else
{
if (_variableFlag)
{
_variableValue = _tagValue;
}
}
break;
case "TEXT":
if (_fieldFlag)
{
_field.text = _tagValue;
}
else
{
}
break;
case "CAPTION":
if (_fieldFlag)
{
_field.caption = _tagValue;
}
else
{
}
break;
case "INSTRUCTIONS":
if (_formFlag)
{
_form.instructions = _tagValue;
}
else
{
if (_fieldFlag)
{
_field.instructions = _tagValue;
}
else
{
}
}
break;
case "PRINTORIENTATION":
if (_formFlag)
{
_form.printOrientation = _tagValue;
}
else
{
if (_fieldFlag)
{
}
else
{
}
}
break;
case "LAYER":
if (_fieldFlag)
{
_field.layer = CommonRoutines.ConvertToInt(_tagValue);
}
else
{
}
break;
case "EDIFLAG":
if (_fieldFlag)
{
_field.ediFlag = (_tagValue + "N").Substring(0, 1);
}
else
{
}
break;
case "EDINAME":
if (_fieldFlag)
{
_field.ediName = _tagValue.ToUpper();
}
else
{
}
break;
default:
// all other tags
if (_fieldFlag)
{
_field.AddProperty(_tagName, _tagValue);
}
else
{
}
break;
}
}
}
}
catch (Exception ex)
{
CommonRoutines.DisplayErrorMessage("$E:" + moduleName + ".CreateForms > " + ex.Message);
}
_numForms = forms.Count;
return _numForms;
}
private void GotoPage(IGenForm form, int pageNo)
{
int _pageNo = pageNo;
// set the cursor
Cursor _saveCursor = this.Cursor;
try
{
this.Cursor = Cursors.WaitCursor;
IGenForm _form = form;
DisplayStatus("Paging form " + _form.name);
// page each of the dataset ordinals
for (int n = 0; n < _form.datasets.Count; n++)
{
int _dsOrdinal = _form.datasets[n].referenceDatasetOrdinal;
// get the dataset defined
if (_dsOrdinal >= 0)
{
_pageNo = pageNo;
// set the pages
_form.datasetOrdinal = _dsOrdinal;
_form.dataset = _form.datasets[n]; // displayIGenForms.datasets[_dsOrdinal];
_form.pages = _form.dataset.pages;
_form.dataset.currentPosition = _pageNo;
_form.rowsPerPage = _form.rowsPerPages[n];
// see if the page number sent is valid for the number of pages determined
if (_form.pages.Count > 0)
{
//if (_pageNo < 1)
//{
// _pageNo = 1;
//}
//else
//{
// if (_pageNo > _form.pages.Count)
// {
// _pageNo = _form.pages.Count;
// }
//}
_form.currentPage = _pageNo;
// offset the row
_pageNo = _pageNo - 1;
// set the referenced dataset
IGenDataset _ds = displayIGenForms.datasets[_dsOrdinal];
if (_pageNo < _form.pages.Count)
{
// get the starting and ending values
int _startingRow = _form.pages[_pageNo].startingRow;
int _endingRow = _form.pages[_pageNo].endingRow;
int _numRows = _endingRow - _startingRow + 1;
tbrMainPageNo.Text = _form.currentPage.ToString();
tbrMainTotalPages.Text = _form.totalPages.ToString();
Application.DoEvents();
// see if there are any rows...
if (_ds.numRows > 0)
{
_ds.currentPosition = _startingRow - 1;
// get the rows for this page
List<string[]> _results = _ds.GetRows(_startingRow, _numRows);
_ds.results = _results;
_form.dataset.results = _results;
if (_results != null && _results.Count > 0)
{
_form.currentRow = _startingRow;
tbrMainPageNo.Text = _form.currentPage.ToString();
tbrMainTotalPages.Text = _form.totalPages.ToString();
Application.DoEvents();
}
}
//DisplayStatus("S=" + _startingRow + ", E=" + _endingRow + ", N=" + _numRows);
}
else
{
// clear out the result set of this dataset
_ds.results.Clear();
_form.dataset.results.Clear();
}
}
}
}
// refresh the page
if (tabForms.SelectedTab != null)
{
string _formName = _form.name;
PictureBox _pallet = (PictureBox)tabForms.SelectedTab.Controls[0];
displayIGenForms.RedisplaySelectedForm(_pallet, _formName);
}
}
catch (Exception ex)
{
CommonRoutines.DisplayErrorMessage("$E:" + moduleName + ".GotoPage > " + ex.Message);
}
this.Cursor = _saveCursor;
DisplayStatus("Ready");
return;
}
