/// <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); }