/// <summary>
/// Get format string for general floating point number
/// </summary>
/// <param name="format"></param>
/// <param name="decimals"></param>
/// <returns></returns>
public static string GetFormatString(
ColumnFormatEnum format,
int decimals)
{
string formatString, txt;
int di;
if (format == ColumnFormatEnum.Unknown || format == ColumnFormatEnum.Default)
{ // if not specified apply user default
format = DefaultNumberFormat;
decimals = DefaultDecimals;
}
// Scientific notation
if (format == ColumnFormatEnum.Scientific)
{
if (decimals <= 0)
{
decimals = 1; // minimum of 1
}
formatString = "{0:e" + decimals.ToString() + "}";
}
// Fixed number of decimal places
else // normal decimal places
{
formatString = "{0:F" + decimals.ToString() + "}";
}
return(formatString);
}
public static DialogResult Show(
QueryColumn qc)
{
string tok;
if (Instance == null)
{
Instance = new TextFormatDialog();
}
TextFormatDialog dfd = Instance;
MetaColumn mc = qc.MetaColumn;
if (mc.DataType != MetaColumnType.String)
{
XtraMessageBox.Show(mc.Label + " is not a string field");
return(DialogResult.Cancel);
}
// Setup
new JupyterGuiConverter().ConvertFormOrUserControl(Instance);
ColumnFormatEnum df = qc.DisplayFormat;
if (df != ColumnFormatEnum.HtmlText)
{
df = qc.MetaColumn.Format;
}
if (df == ColumnFormatEnum.NormalText)
{
dfd.NormalFormatCheckEdit.Checked = true;
}
else if (df == ColumnFormatEnum.HtmlText)
{
dfd.HtmlCheckEdit.Checked = true;
}
else
{
dfd.NormalFormatCheckEdit.Checked = true; // in case of no match
}
// Show form & get new values
DialogResult dr = dfd.ShowDialog(SessionManager.ActiveForm);
if (dr == DialogResult.OK)
{
if (dfd.NormalFormatCheckEdit.Checked)
{
qc.DisplayFormat = ColumnFormatEnum.NormalText;
}
else
{
qc.DisplayFormat = ColumnFormatEnum.HtmlText;
}
}
return(dr);
}
/// <summary>
/// Reset formatting to default values
/// </summary>
public void ResetFormatting()
{
QueryColumn qc0 = new QueryColumn();
CondFormat = qc0.CondFormat;
Label = qc0.Label;
DisplayFormat = qc0.DisplayFormat;
DisplayWidth = qc0.DisplayWidth;
Decimals = qc0.Decimals;
HorizontalAlignment = qc0.HorizontalAlignment;
VerticalAlignment = qc0.VerticalAlignment;
return;
}
/// <summary>
/// Format a basic qualified number with qualifier and value
/// </summary>
/// <param name="qn"></param>
/// <param name="displayFormat"></param>
/// <param name="decimals"></param>
/// <returns></returns>
public string Format(
ColumnFormatEnum displayFormat,
int decimals)
{
string result;
QualifiedNumber qn = this;
if (qn.Qualifier == null)
{
qn.Qualifier = "";
}
if (qn.TextValue == null)
{
qn.TextValue = "";
}
if (qn.Hyperlink == null)
{
qn.Hyperlink = "";
}
if (qn.NumberValue == NullValue.NullNumber)
{
if (qn.NValue != NullValue.NullNumber)
{
return("ND"); // some NValue, return not determined
}
else
{
return(qn.TextValue);
}
}
result = FormatNumber(qn.NumberValue, displayFormat, decimals);
if (qn.Qualifier != "")
{
result = qn.Qualifier + result;
}
return(result);
}
/// <summary>
/// Add a DataColumn to a DataTable that will be used to create an annotation table
/// </summary>
/// <param name="dataTable">DataTable to add column to</param>
/// <param name="columnName">Name for column</param>
/// <param name="caption">Caption/label for column</param>
/// <param name="dataType">Datatype for column</param>
/// <param name="displayLevel">Initial level of display for this column</param>
/// <param name="displayWidth">Width for column in characters</param>
/// <param name="displayFormat">Type of display for numeric columns</param>
/// <param name="decimals">Number of decimals/precision for numeric values</param>
/// <returns>Added DataColumn</returns>
public static DataColumn AddDataColumn(
DataTable dataTable,
string columnName,
string caption,
Type dataType,
ColumnSelectionEnum displayLevel,
float displayWidth,
ColumnFormatEnum displayFormat,
int decimals)
{
DataColumn dc = new DataColumn(columnName, dataType);
dc.Caption = caption;
dc.ExtendedProperties.Add("DisplayLevel", displayLevel);
dc.ExtendedProperties.Add("DisplayWidth", displayWidth);
dc.ExtendedProperties.Add("DisplayFormat", displayFormat);
dc.ExtendedProperties.Add("Decimals", decimals);
dataTable.Columns.Add(dc);
return(dc);
}
/// <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>
/// Customize the display text for the cells displayed within the Data Area.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Grid_CustomCellDisplayText(object sender, PivotCellDisplayTextEventArgs e)
{
string txt;
QualifiedNumber qn = e.Value as QualifiedNumber; // summary values should be QNs
if (qn == null)
{
return;
}
PivotGridFieldContext f = GetPivotGridFieldContext(e.DataField);
AggregationTypeDetail atd = f.Aggregation.TypeDetail;
if (atd == null || !atd.FractionalSummaryResult)
{
return; // just return if not numeric type
}
if (qn.IsNull)
{
e.DisplayText = "";
return;
}
ColumnFormatEnum displayFormat = f.Qc.ActiveDisplayFormat;
int decimals = f.Qc.ActiveDecimals;
if (f.Mc.DataType == MetaColumnType.Integer)
{
displayFormat = ColumnFormatEnum.Decimal;
decimals = 1;
}
txt = qn.Format(f.Qc, false, displayFormat, decimals, QnfEnum.Combined | QnfEnum.NValue, OutputDest.WinForms);
e.DisplayText = txt;
return;
}
/// <summary>
/// Basic floating point number formatter
/// </summary>
/// <param name="number"></param>
/// <param name="format"></param>
/// <param name="decimals"></param>
/// <returns></returns>
public static string FormatNumber(
double number,
ColumnFormatEnum format,
int decimals)
{
string formatString, txt;
int di;
if (number == NullValue.NullNumber)
{
return("");
}
if (format == ColumnFormatEnum.Unknown || format == ColumnFormatEnum.Default)
{ // if not specified apply user default
format = DefaultNumberFormat;
decimals = DefaultDecimals;
}
// Scientific notation
try
{
if (format == ColumnFormatEnum.Scientific)
{
if (decimals <= 0)
{
decimals = 1; // minimum of 1
}
formatString = "{0:e" + decimals.ToString() + "}";
txt = String.Format(formatString, number);
if (txt.IndexOf("e+") > 0)
{
txt = txt.Replace("e+00", "e+");
}
else
{
txt = txt.Replace("e-00", "e-"); // remove extra exponent zeros
}
}
// Fixed number of significant digits
else if (format == ColumnFormatEnum.SigDigits)
{
if (number == 0) // if zero then show enough digits
{
return(FormatNumber(number, ColumnFormatEnum.Decimal, decimals - 1));
}
double absVal = Math.Abs(number);
if (absVal > 1000000.0 || absVal < 0.000001) // if extreme do as scientific
{
return(FormatNumber(number, ColumnFormatEnum.Scientific, decimals));
}
// Get position of 1st significant digit. Digits are numbered as follows
// 7 654 321 012345 (neg numbers if right of decimal)
// 1,000,000.000001
double n2 = 1000000.0;
for (di = 7; di >= -5; di--)
{
if (absVal >= n2)
{
break;
}
n2 = n2 / 10;
}
int sigDigits = decimals; // significant digits stored in decimals variable
if (sigDigits <= 0)
{
sigDigits = 1; // minimum of 1
}
if (sigDigits < di) // no decimals, round & truncate non-sig digits in integer portion
{
decimals = 0; // nothing to right of decimal
double factor = Math.Pow(10, di - sigDigits); // factor for rounding & truncating
number += .5 * factor * Math.Sign(number); // round appropriately
number = ((long)(number / factor)) * factor; // truncate
}
else
{
decimals = sigDigits - di; // number of decimals needed
}
return(FormatNumber(number, ColumnFormatEnum.Decimal, decimals));
}
// Fixed number of decimal places
else // normal decimal places
{
formatString = "{0:F" + decimals.ToString() + "}";
txt = String.Format(formatString, number);
}
return(txt);
}
catch (Exception ex)
{
return("FormatNumber Error");
}
}
/// <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);
}
