/// <summary>
/// Copy ExportParms members to ResultsFormat
/// </summary>
/// <param name="ep"></param>
public void CopyFromExportParms(ExportParms ep)
{
QueryId = ep.QueryId;
OutputDestination = ep.OutputDestination;
RunInBackground = ep.RunInBackground;
ExportFileFormat = ep.ExportFileFormat;
OutputFileName = ep.OutputFileName;
OutputFileName2 = ep.OutputFileName2;
DuplicateKeyTableValues = ep.DuplicateKeyValues;
if (ep.QualifiedNumberSplit != QnfEnum.Undefined)
{
QualifiedNumberSplit = ep.QualifiedNumberSplit;
}
ExportStructureFormat = ep.ExportStructureFormat;
StructureFlags = ep.StructureFlags;
FixedHeightStructures = ep.FixedHeightStructures;
ColumnNameFormat = ep.ColumnNameFormat;
IncludeDataTypes = ep.IncludeDataTypes;
OpenMode = ep.OpenMode;
ViewStructures = ep.ViewStructures;
return;
}
/// <summary>
/// Setup text control with split option
/// </summary>
/// <param name="rf"></param>
/// <param name="control"></param>
public void Setup(QnfEnum qnf)
{
if ((qnf & QnfEnum.Split) != 0)
{
qnf |= QnfEnum.Qualifier | QnfEnum.NumericValue; // these are required
QnfSplit.Checked = true;
string tok = SerializeQualifiedNumberSplit(qnf);
QnfSplitFormat.Text = tok;
}
else
{
QnfCombined.Checked = true;
QnfSplitFormat.Text = "Qualifier, Number";
}
}
/// <summary>
/// Format qualified number when destination device not known
/// </summary>
/// <param name="qc"></param>
/// <param name="mergedField"></param>
/// <param name="displayFormat"></param>
/// <param name="decimals"></param>
/// <param name="qnFormat"></param>
/// <param name="includeLink"></param>
/// <returns></returns>
public string Format(
QueryColumn qc,
bool mergedField,
ColumnFormatEnum displayFormat,
int decimals,
QnfEnum qnFormat,
bool includeLink)
{
OutputDest outputDest;
if (includeLink)
{
outputDest = OutputDest.WinForms;
}
else
{
outputDest = OutputDest.TextFile;
}
return(Format(qc, mergedField, displayFormat, decimals, qnFormat, outputDest));
}
/// <summary>
/// Format qualified number
/// </summary>
/// <param name="qn"></param>
/// <param name="qc"></param>
/// <param name="mergedField"></param>
/// <param name="displayFormat"></param>
/// <param name="decimals"></param>
/// <param name="qnFormat"></param>
/// <param name="outputDest"></param>
/// <returns></returns>
public string Format(
QueryColumn qc,
bool mergedField,
ColumnFormatEnum displayFormat,
int decimals,
QnfEnum qnFormat,
OutputDest outputDest)
{
string result, uri, href, txt, tok;
result = "";
QualifiedNumber qn = this;
MetaColumn mc = qc.MetaColumn;
if (qn.Qualifier == null)
{
qn.Qualifier = "";
}
if (qn.TextValue == null)
{
qn.TextValue = "";
}
if (qn.Hyperlink == null)
{
qn.Hyperlink = "";
}
if (QnSubcolumns.IsCombinedFormat(qnFormat)) // normal combined number
{
if (qn.NumberValue == NullValue.NullNumber && qn.NValue == NullValue.NullNumber &&
qn.NValueTested == NullValue.NullNumber && qn.TextValue == "")
{ // null value
result = NullValueString;
if (outputDest == OutputDest.Html && (NullValueString == "" || NullValueString == " "))
{
result = "<br>"; // html blank
}
return(result);
}
result = qn.Format(displayFormat, decimals);
if (qn.NValue > 1 || qn.NValueTested > 1 || // format with sd, n
(qn.NValue >= 0 && qn.NValueTested > qn.NValue) || // number tested > n
(qn.NumberValue == NullValue.NullNumber && // also null numbers if some nonzero nvalue
(qn.NValue > 0 || qn.NValueTested > 0)))
{
txt = "";
if (qn.NValue > 1 && (qnFormat & QnfEnum.StdDev) != 0 && // include sd
(qn.StandardDeviation != NullValue.NullNumber ||
qn.StandardError != NullValue.NullNumber))
{ // format standard deviation
if ((qnFormat & QnfEnum.DisplayStdDevLabel) != 0)
{
txt += "sd=";
}
if (qn.StandardDeviation == NullValue.NullNumber) // calc sd from se if don't have
{
qn.StandardDeviation = qn.StandardError * Math.Sqrt(qn.NValue);
}
txt += FormatNumber(qn.StandardDeviation, displayFormat, decimals);
}
if (qn.NValue > 1 && (qnFormat & QnfEnum.StdErr) != 0 && // include se
(qn.StandardError != NullValue.NullNumber ||
qn.StandardDeviation != NullValue.NullNumber))
{ // format standard error
if (txt != "")
{
txt += ", ";
}
if ((qnFormat & QnfEnum.DisplayStdErrLabel) != 0)
{
txt += "se=";
}
txt += FormatNumber(qn.StandardError, displayFormat, decimals);
}
if (qn.NValue != NullValue.NullNumber &&
(qnFormat & QnfEnum.NValue) != 0)
{ // format n value
if (txt != "")
{
txt += ", ";
}
if ((qnFormat & QnfEnum.DisplayNLabel) != 0)
{
txt += "n=";
}
txt += qn.NValue.ToString();
if (qn.NValueTested != NullValue.NullNumber && qn.NValueTested != qn.NValue)
{
txt += "/" + qn.NValueTested.ToString(); // add number tested if different
}
}
if (txt != "")
{
result += " (" + txt + ")"; // build complete string
}
}
if (qn.DbLink != null && qn.DbLink != "" && qn.DbLink != "." && !mergedField && // do we have an associated resultId
(outputDest == OutputDest.WinForms || outputDest == OutputDest.Html))
{
uri = qn.FormatHyperlink(qc);
//if (outputDest == OutputDest.Grid) // store link info in separate field
// qn.Hyperlink = uri;
//else if (outputDest == OutputDest.Html) // build full html tag
//{
if (uri != "")
{
result = result = "<a href=" + Lex.Dq(uri) + ">" + result + "</a>";
}
//}
}
}
// Format one piece of a split qualified number
else if ((qnFormat & QnfEnum.Qualifier) != 0) // qualifier
{
result = qn.Qualifier;
}
else if ((qnFormat & QnfEnum.NumericValue) != 0) // basic number
{
if (qn.NumberValue != NullValue.NullNumber)
{
result = FormatNumber(qn.NumberValue, displayFormat, decimals);
}
else
{
result = null;
}
//else (obsolete, don't output any text values into numeric column, add option for separate column later)
//{
// if (qn.NValue != NullValue.NullNumber)
// result = "ND"; // some NValue, return not determined
// else result = qn.TextValue; // return any text value
//}
}
else if ((qnFormat & QnfEnum.StdDev) != 0) // standard deviation
{
if (qn.StandardDeviation != NullValue.NullNumber)
{
result = FormatNumber(qn.StandardDeviation, displayFormat, decimals);
}
}
else if ((qnFormat & QnfEnum.StdErr) != 0) // standard error
{
if (qn.StandardError != NullValue.NullNumber)
{
result = FormatNumber(qn.StandardError, displayFormat, decimals);
}
}
else if ((qnFormat & QnfEnum.NValue) != 0) // N
{
if (qn.NValue != NullValue.NullNumber)
{
result = qn.NValue.ToString();
}
}
else if ((qnFormat & QnfEnum.NValueTested) != 0) // number tested
{
if (qn.NValueTested != NullValue.NullNumber)
{
result = qn.NValueTested.ToString();
}
}
else if ((qnFormat & QnfEnum.TextValue) != 0) // text value
{
if (!Lex.IsNullOrEmpty(qn.TextValue))
{
result = qn.TextValue;
}
}
return(result);
}
/// <summary>
/// Serialize the QualifiedNumberSplit settings
/// </summary>
/// <param name="qnf"></param>
/// <returns></returns>
public static string SerializeQualifiedNumberSplit(
QnfEnum qnf)
{
if ((qnf & QnfEnum.Combined) != 0)
{
return("");
}
string txt = "";
if ((qnf & QnfEnum.Qualifier) != 0)
{
if (txt != "")
{
txt += ", ";
}
txt += "Qualifier";
}
if ((qnf & QnfEnum.NumericValue) != 0)
{
if (txt != "")
{
txt += ", ";
}
txt += "Number";
}
if ((qnf & QnfEnum.StdDev) != 0)
{
if (txt != "")
{
txt += ", ";
}
txt += "SD";
}
if ((qnf & QnfEnum.StdErr) != 0)
{
if (txt != "")
{
txt += ", ";
}
txt += "SE";
}
if ((qnf & QnfEnum.NValue) != 0)
{
if (txt != "")
{
txt += ", ";
}
txt += "N";
}
if ((qnf & QnfEnum.NValueTested) != 0)
{
if (txt != "")
{
txt += ", ";
}
txt += "NT";
}
if ((qnf & QnfEnum.TextValue) != 0)
{
if (txt != "")
{
txt += ", ";
}
txt += "Text";
}
return(txt);
}
