private void SetCellValue(int i_Row, int i_Col, object i_Value, FormatTypes i_Type)
{
if (i_Value != null)
{
this.PrintingTable.GetCell(i_Row, i_Col).Text = this.FormatValue(i_Value, i_Type);
}
}
/// <summary>
/// Adds an entry to the chat history box.
/// </summary>
/// <param name="text">The text to be added.</param>
private void UpdateChatHistory(string text, FormatTypes formatType)
{
// This code block ensures optimum line spacing between different types of formatted texts.
switch (lastFormatType)
{
case FormatTypes.Status:
if (formatType != FormatTypes.Status)
{
rtbMessageHistory.AppendTextAsRtf("\n");
}
break;
case FormatTypes.Message:
if (formatType != FormatTypes.UserName)
{
rtbMessageHistory.AppendTextAsRtf("\n");
}
break;
}
lastFormatType = formatType;
// Ensure there is no more than one blank line between messages.
if (text.StartsWith(Environment.NewLine))
{
if (rtbMessageHistory.Text.EndsWith("\n\n"))
{
text = text.TrimStart(Environment.NewLine.ToCharArray());
}
}
switch (formatType)
{
case FormatTypes.UserName:
case FormatTypes.Status:
rtbMessageHistory.AppendTextAsRtf(text, Definitions.GetPresetFont(formatType), Definitions.GetPresetColor(formatType));
break;
case FormatTypes.Message:
string rtfText = DecodeEmoticons(text);
rtfText = rtfText.Insert(rtfText.LastIndexOf(@"\f0"), @"\li240");
rtbMessageHistory.AppendRtf(rtfText);
// Enable button that saves chat history.
if (!bCanSave && rtbMessageHistory.TextLength > 0)
{
tbBtnSave.Enabled = true;
bCanSave = true;
}
break;
default:
rtbMessageHistory.AppendTextAsRtf(text);
break;
}
// For auto scrolling chat history box.
rtbMessageHistory.ScrollToBottom();
}
public static IFeedFormatter GetFormatter(FormatTypes feedFormat)
{
switch (feedFormat)
{
case FormatTypes.XML:
case FormatTypes.JSON:
default:
return(new JSONFormatter());
}
}
/// <summary>
/// Initializes a new instance of the object class with the default values
/// </summary>
public TextNumberFormat()
{
this.numberFormat = new NumberFormatInfo();
this.numberFormatType = TextNumberFormat.FormatTypes.General;
this.groupingActivated = true;
this.separator = this.GetSeparator(TextNumberFormat.FormatTypes.General);
this.maxIntDigits = 127;
this.minIntDigits = 1;
this.maxFractionDigits = 3;
}
/// <summary>
/// Initializes a new instance of the class with the specified number format,
/// uses the system's culture information,
/// and assigns the amount of fractional digits to use
/// </summary>
/// <param name="theType">Number format</param>
/// <param name="cultureNumberFormat">Represents information about a specific culture including the number formatting</param>
/// <param name="digits">Number of fractional digits to use</param>
private TextNumberFormat(TextNumberFormat.FormatTypes theType,
CultureInfo cultureNumberFormat, int digits)
{
this.numberFormat = cultureNumberFormat.NumberFormat;
this.numberFormatType = theType;
this.groupingActivated = true;
this.separator = this.GetSeparator(theType);
this.maxIntDigits = 127;
this.minIntDigits = 1;
this.maxFractionDigits = 3;
}
/// <summary>
/// Initializes a new instance of the class with the specified number format
/// and the amount of fractional digits to use
/// </summary>
/// <param name="theType">Number format</param>
/// <param name="digits">Number of fractional digits to use</param>
private TextNumberFormat(TextNumberFormat.FormatTypes theType,
int digits)
{
this.numberFormat = NumberFormatInfo.CurrentInfo;
this.numberFormatType = theType;
this.groupingActivated = true;
this.separator = this.GetSeparator(theType);
this.maxIntDigits = 127;
this.minIntDigits = 1;
this.maxFractionDigits = 3;
}
public static Color GetPresetColor(FormatTypes formatType)
{
foreach (KeyValuePair <FormatTypes, Color> color in presetColors)
{
if (color.Key == formatType)
{
return(color.Value);
}
}
return(Color.Transparent);
}
public static Font GetPresetFont(FormatTypes formatType)
{
foreach (KeyValuePair <FormatTypes, Font> font in presetFonts)
{
if (font.Key == formatType)
{
return(font.Value);
}
}
return(null);
}
public ResultViewerViewModel(IEzSbytServiceFunctionViewModel parent, ServiceResult data, FormatTypes formatType) : this()
{
if (parent == null)
{
throw new ArgumentNullException("Parent must be not null!");
}
_parent = parent;
SelectedFormatType = formatType;
_data = data;
InitSource();
}
private void setValidationString(String val)
{
//read format
FormatTypes.Clear();
foreach (char ch in val.ToCharArray())
{
if (ch.Equals('*'))
{
FormatTypes.Add(CharType.AnyLetterDigit);
}
else if (ch.Equals('~'))
{
FormatTypes.Add(CharType.Letter);
}
else if (ch.Equals('!'))
{
FormatTypes.Add(CharType.UpperCaseLetter);
}
else if (ch.Equals('_'))
{
FormatTypes.Add(CharType.LowerCaseLetter);
}
else if (ch.Equals('#'))
{
FormatTypes.Add(CharType.Digit);
}
else if (ch.Equals('%'))
{
FormatTypes.Add(CharType.Double);
}
else
{
FormatTypes.Add(CharType.Fixed);
}
}
//show completion string
String str = "";
for (int i = 0; i < FormatTypes.Count; i++)
{
CharType type = FormatTypes[i];
if (type == CharType.Fixed)
{
str += val[i];
}
else
{
str += MaskChar;
}
}
this.Text = str;
this.FormatTypes = FormatTypes;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sourceColumnName">The name of the source column</param>
/// <param name="formatString"></param>
/// <param name="formatType">The format type to use when processing this rule</param>
public Rule_Format(DashboardHelper dashboardHelper, string friendlyRule, string sourceColumnName, string destinationColumnName, string formatString, FormatTypes formatType)
{
this.friendlyRule = friendlyRule;
this.formatString = formatString;
this.sourceColumnName = sourceColumnName;
this.destinationColumnName = destinationColumnName;
this.formatType = formatType;
this.suffix = string.Empty;
this.dashboardHelper = dashboardHelper;
this.destinationColumnType = "System.String";
Construct();
}
public string Format(FormatTypes inputType, string input)
{
switch (inputType)
{
case FormatTypes.Json:
return(_jsonFormatter.Format(input));
case FormatTypes.Html:
return(_htmlFormatter.Format(input));
default:
throw new Exception("unsupported format type!");
}
}
// Formatlama işlemini yapan metod
public string Format(FormatTypes inputType, string input)
{
switch (inputType)
{
case FormatTypes.Json:
return(_jsonFormatter.Format(input));
case FormatTypes.Html:
return(_htmlFormatter.Format(input));
default:
throw new Exception("Desteklenmeyen format tipi!");
}
}
/// <summary>
/// Creates the rule from an Xml element
/// </summary>
/// <param name="element">The XmlElement from which to create the rule</param>
public override void CreateFromXml(System.Xml.XmlElement element)
{
foreach (XmlElement child in element.ChildNodes)
{
if (child.Name.Equals("friendlyRule"))
{
this.friendlyRule = child.InnerText;
}
else if (child.Name.Equals("sourceColumnName"))
{
this.sourceColumnName = child.InnerText;
}
else if (child.Name.Equals("destinationColumnName"))
{
this.destinationColumnName = child.InnerText;
}
else if (child.Name.Equals("destinationColumnType"))
{
this.destinationColumnType = child.InnerText;
}
else if (child.Name.Equals("formatString"))
{
this.formatString = child.InnerText;
}
else if (child.Name.Equals("formatType"))
{
this.formatType = ((FormatTypes)Int32.Parse(child.InnerText));
}
}
if (this.FormatType.Equals(FormatTypes.Hours))
{
this.destinationColumnType = "System.Decimal";
this.variableType = DashboardVariableType.Numeric;
}
else if (this.FormatType.Equals(FormatTypes.EpiWeek))
{
this.destinationColumnType = "System.Decimal";
this.variableType = DashboardVariableType.Numeric;
}
else if (destinationColumnType.Equals("System.String"))
{
this.variableType = DashboardVariableType.Text;
}
else if (destinationColumnType.Equals("System.Single") || destinationColumnType.Equals("System.Double") || destinationColumnType.Equals("System.Decimal") || destinationColumnType.Equals("System.Int16") || destinationColumnType.Equals("System.Int32"))
{
this.variableType = DashboardVariableType.Numeric;
}
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="start">start position</param>
/// <param name="length">length</param>
/// <param name="record">record line</param>
/// <param name="format">format</param>
public void Parse(string record, int start = -1, int length = -1, FormatTypes format = FormatTypes.None)
{
string value = string.Empty;
var lineLength = start + length;
this._Start = start;
this._Length = length;
//get the value from the record
if (!string.IsNullOrEmpty(record))
{
//If start position and length is -1 then no need to get value, just need to apply formatting
if (start == -1 && length == -1)
{
value = record;
}
else
{
if (record.Length >= lineLength)
{
value = record.Substring(this.Start, this.Length);
}
}
}
///Format according to format type provided
switch (format)
{
//date format
case FormatTypes.DateFormat:
value = Utility.FormatDate(value);
break;
//remove prefix zeros
case FormatTypes.RemovePrefixZeros:
value = Utility.ReplacePrefixZeros(value);
break;
//Do nothing
case FormatTypes.None:
default:
//Do nothing
break;
}
this._Value = value.Trim();
}
// ////////////////////////////////////////////////////////////////////////////
//IsFormat => cette méthode fonctionne comme un filtre qui nous renseigne sur les ensembles de valeurs d'énumération (elle contient une instruction switch).
//Renvoie vrai si le FormatType est Gras ou Italique.
static bool IsFormat(FormatTypes value)
{
switch (value)
{
case FormatTypes.BoldFormat:
case FormatTypes.ItalicsFormat:
{
// Ces 2 valeurs sont des valeurs de format.
return(true);
}
default:
{
// L'argument n'est pas une valeur de format.
return(false);
}
}
}
/// <summary>
/// 格式化
/// </summary>
/// <param name="formatType"></param>
/// <param name="value"></param>
/// <returns></returns>
private static string Format(FormatTypes formatType, object value)
{
switch (formatType)
{
case FormatTypes.Percent:
return(((decimal)value).ToString("P"));
case FormatTypes.Date:
return(value == null ? string.Empty : (Convert.ToDateTime(value)).ToString("yyyy-MM-dd"));
case FormatTypes.DateTime:
return(value == null ? string.Empty : (Convert.ToDateTime(value)).ToString("yyyy-MM-dd HH:mm:ss"));
case FormatTypes.None:
default:
return(value == null ? string.Empty : value.ToString());
}
}
private string FormatValue(object i_value, FormatTypes i_Type)
{
switch (i_Type)
{
case FormatTypes.Decimal:
return(string.Format("{0:0.00}", i_value));
case FormatTypes.Int:
return(string.Format("{0:0}", i_value));
case FormatTypes.Precent:
return(string.Format("{0:0%}", i_value));
case FormatTypes.String:
default:
return(i_value.ToString());
}
}
/// <summary>
/// Handles the SelectionChanged Event for cbxFormatOptions.
/// Code for EpiWeek is commented as being out of scope.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void cbxFormatOptions_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (cbxFormatOptions.SelectedIndex >= 0)
{
FormatTypes type = GetFormatType();
if (type != FormatTypes.EpiWeek)
{
//EwavRule_Format tempFormatRule = new EwavRule_Format();//dashboardHelper, "temp", "temp", "temp", "temp", type);
string formatString = GetFormatString(type);
txtPreview.Text = string.Format(System.Globalization.CultureInfo.CurrentCulture, formatString, DateTime.Now);
}
else
{
//StatisticsRepository.EpiWeek epiWeek = new StatisticsRepository.EpiWeek();
txtPreview.Text = GetEpiWeek(DateTime.Now).ToString().Trim();
}
}
}
public ChatControl()
{
InitializeComponent();
InitUI();
rtbMessage.ContextMenu = mnuMessageBox;
rtbMessage.AllowDrop = true;
rtbMessage.DragEnter += new DragEventHandler(TextBox_DragEnter);
rtbMessage.DragDrop += new DragEventHandler(TextBox_DragDrop);
rtbMessageHistory.AllowDrop = true;
rtbMessageHistory.DragEnter += new DragEventHandler(TextBox_DragEnter);
rtbMessageHistory.DragDrop += new DragEventHandler(TextBox_DragDrop);
fontList = new List <string>();
colorList = new List <string>();
bEnabled = true;
bWindowed = false;
bCanSave = false;
lastTypeTime = DateTime.MinValue;
lastFormatType = FormatTypes.Default;
}
public static dynamic GetTSObject(FormatTypes dynEnum)
{
var tsType = TSActivator.CreateInstance("Tekla.Structures.Drawing.FormatTypes").GetType();
switch (dynEnum)
{
case FormatTypes.Automatic:
return(System.Enum.Parse(tsType, "Automatic"));
case FormatTypes.WholeNumber:
return(System.Enum.Parse(tsType, "WholeNumber"));
case FormatTypes.OneDecimalIfValidDecimal:
return(System.Enum.Parse(tsType, "OneDecimalIfValidDecimal"));
case FormatTypes.OneDecimal:
return(System.Enum.Parse(tsType, "OneDecimal"));
case FormatTypes.TwoDecimalsIfValidDecimals:
return(System.Enum.Parse(tsType, "TwoDecimalsIfValidDecimals"));
case FormatTypes.TwoDecimals:
return(System.Enum.Parse(tsType, "TwoDecimals"));
case FormatTypes.ThreeDecimalsIfValidDecimals:
return(System.Enum.Parse(tsType, "ThreeDecimalsIfValidDecimals"));
case FormatTypes.ThreeDecimals:
return(System.Enum.Parse(tsType, "ThreeDecimals"));
case FormatTypes.Fractional:
return(System.Enum.Parse(tsType, "Fractional"));
default:
throw new DynamicAPIException(dynEnum.ToString() + "- enum value is not implemented");
}
}
/// <summary>
/// Retrieves the separator used, depending on the format type specified
/// </summary>
/// <param name="numberFormatType">formatType enumarator value to inquire</param>
/// <returns>The values of character separator used </returns>
private string GetSeparator(FormatTypes numberFormatType)
{
string separatorItem = " "; //Default Separator
switch (numberFormatType)
{
case TextNumberFormat.FormatTypes.Currency:
separatorItem = this.numberFormat.CurrencyGroupSeparator;
break;
case TextNumberFormat.FormatTypes.General:
separatorItem = this.numberFormat.NumberGroupSeparator;
break;
case TextNumberFormat.FormatTypes.Number:
separatorItem = this.numberFormat.NumberGroupSeparator;
break;
case TextNumberFormat.FormatTypes.Percent:
separatorItem = this.numberFormat.PercentGroupSeparator;
break;
}
return(separatorItem);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sourceColumnName">The name of the source column</param>
/// <param name="formatString"></param>
/// <param name="formatType">The format type to use when processing this rule</param>
public Rule_Format(DashboardHelper dashboardHelper, string friendlyRule, string sourceColumnName, string destinationColumnName, string formatString, FormatTypes formatType)
{
this.friendlyRule = friendlyRule;
this.formatString = formatString;
this.sourceColumnName = sourceColumnName;
this.destinationColumnName = destinationColumnName;
this.formatType = formatType;
this.suffix = string.Empty;
this.dashboardHelper = dashboardHelper;
this.destinationColumnType = "System.String";
Construct();
}
/// <summary>
/// Creates the rule from an Xml element
/// </summary>
/// <param name="element">The XmlElement from which to create the rule</param>
public override void CreateFromXml(System.Xml.XmlElement element)
{
foreach (XmlElement child in element.ChildNodes)
{
if (child.Name.Equals("friendlyRule"))
{
this.friendlyRule = child.InnerText;
}
else if (child.Name.Equals("sourceColumnName"))
{
this.sourceColumnName = child.InnerText;
}
else if (child.Name.Equals("destinationColumnName"))
{
this.destinationColumnName = child.InnerText;
}
else if (child.Name.Equals("destinationColumnType"))
{
this.destinationColumnType = child.InnerText;
}
else if (child.Name.Equals("formatString"))
{
this.formatString = child.InnerText;
}
else if (child.Name.Equals("formatType"))
{
this.formatType = ((FormatTypes)Int32.Parse(child.InnerText));
}
}
if (this.FormatType.Equals(FormatTypes.Hours))
{
this.destinationColumnType = "System.Decimal";
this.variableType = DashboardVariableType.Numeric;
}
else if (this.FormatType.Equals(FormatTypes.EpiWeek))
{
this.destinationColumnType = "System.Decimal";
this.variableType = DashboardVariableType.Numeric;
}
else if (destinationColumnType.Equals("System.String"))
{
this.variableType = DashboardVariableType.Text;
}
else if (destinationColumnType.Equals("System.Single") || destinationColumnType.Equals("System.Double") || destinationColumnType.Equals("System.Decimal") || destinationColumnType.Equals("System.Int16") || destinationColumnType.Equals("System.Int32"))
{
this.variableType = DashboardVariableType.Numeric;
}
}
/// <summary>
/// Gets the format string for this rule
/// </summary>
public string GetFormatString(FormatTypes type)
{
string formatString = string.Empty;
switch (type)
{
case FormatTypes.EpiWeek:
formatString = "epiweek"; // note: Special case scenario
break;
case FormatTypes.Day:
formatString = "{0:dd}";
break;
case FormatTypes.ShortDayName:
formatString = "{0:ddd}";
break;
case FormatTypes.FullDayName:
formatString = "{0:dddd}";
break;
case FormatTypes.FourDigitYear:
formatString = "{0:yyyy}";
break;
case FormatTypes.TwoDigitYear:
formatString = "{0:yy}";
break;
case FormatTypes.DayMonth:
formatString = "{0:M}";
break;
case FormatTypes.Month:
formatString = "{0:MM}";
break;
case FormatTypes.ShortMonthName:
formatString = "{0:MMM}";
break;
case FormatTypes.FullMonthName:
formatString = "{0:MMMM}";
break;
case FormatTypes.RFC1123:
formatString = "{0:r}";
break;
case FormatTypes.RegularDate:
formatString = "{0:d}";
break;
case FormatTypes.LongDate:
formatString = "{0:D}";
break;
case FormatTypes.SortableDateTime:
formatString = "{0:s}";
break;
case FormatTypes.MonthYear:
formatString = "{0:y}";
break;
case FormatTypes.Hours:
formatString = "{0:HH}";
break;
case FormatTypes.HoursMinutes:
formatString = "{0:t}";
break;
case FormatTypes.HoursMinutesSeconds:
formatString = "{0:T}";
break;
case FormatTypes.NumericInteger:
formatString = "{0:0}";
break;
case FormatTypes.NumericDecimal1:
formatString = "{0:0.0}";
break;
case FormatTypes.NumericDecimal2:
formatString = "{0:0.00}";
break;
case FormatTypes.NumericDecimal3:
formatString = "{0:0.000}";
break;
case FormatTypes.NumericDecimal4:
formatString = "{0:0.0000}";
break;
case FormatTypes.NumericDecimal5:
formatString = "{0:0.00000}";
break;
case FormatTypes.MonthAndFourDigitYear:
formatString = "{0:y}";
break;
}
return(formatString);
}
/// <summary>
/// Gets the appropriate FormatType based on the selected format option
/// </summary>
/// <returns>FormatType</returns>
private FormatTypes GetFormatType()
{
#region Input Validation
if (cbxFormatOptions.SelectedItem == null)
{
//throw new ApplicationException("No value selected for the format option.");
}
#endregion // Input Validation
FormatTypes formatType = FormatTypes.Day;
string option = cbxFormatOptions.SelectedItem.ToString();
switch (option)
{
case "an integer":
formatType = FormatTypes.NumericInteger;
break;
case "a decimal with one digit":
formatType = FormatTypes.NumericDecimal1;
break;
case "a decimal with two digits":
formatType = FormatTypes.NumericDecimal2;
break;
case "a decimal with three digits":
formatType = FormatTypes.NumericDecimal3;
break;
case "a decimal with four digits":
formatType = FormatTypes.NumericDecimal4;
break;
case "a decimal with five digits":
formatType = FormatTypes.NumericDecimal5;
break;
case "the day":
formatType = FormatTypes.Day;
break;
case "the day name":
formatType = FormatTypes.FullDayName;
break;
case "the abbreviated day name":
formatType = FormatTypes.ShortDayName;
break;
case "the month":
formatType = FormatTypes.Month;
break;
case "the month and four-digit year":
formatType = FormatTypes.MonthAndFourDigitYear;
break;
case "the month name":
formatType = FormatTypes.FullMonthName;
break;
case "the abbreviated month name":
formatType = FormatTypes.ShortMonthName;
break;
case "the standard date":
formatType = FormatTypes.RegularDate;
break;
case "the long date":
formatType = FormatTypes.LongDate;
break;
case "the epi week":
formatType = FormatTypes.EpiWeek;
break;
case "the four-digit year":
formatType = FormatTypes.FourDigitYear;
break;
case "the two-digit year":
formatType = FormatTypes.TwoDigitYear;
break;
case "the RFC 1123 date":
formatType = FormatTypes.RFC1123;
break;
case "the sortable date":
formatType = FormatTypes.SortableDateTime;
break;
case "the hour":
formatType = FormatTypes.Hours;
break;
}
return(formatType);
}
public PropertyFormatAttribute(FormatTypes type)
{
this.Type = type;
}
public string ParseWithFormat(FormatTypes formatType)
{
var formatter = FeedFormatterFactory.GetFormatter(formatType);
throw new System.NotImplementedException();
}
static void Main(string[] args)
{
//***** Exemple 1 *****
// Spécifiez une instance de balise.
ColorTypes tagValue = ColorTypes.Rouge;
if (tagValue == ColorTypes.Rouge)
{
// Sera afficher.
Console.WriteLine("Rouge");
}
else
{
// Ne Sera pas afficher.
Console.WriteLine("Pas Vrai");
}
Console.WriteLine();
//Affiche :
//Rouge
//***** Exemple 2 *****
//Console.WriteLine peut appeler automatiquement la méthode ToString.
// ... Deux variables enum.
ColorTypes color = ColorTypes.Bleu;
VisibilityTypes visible = VisibilityTypes.Hidden;
// ... Utilisez Console.WriteLine pour imprimer les valeurs d'héritier.
Console.WriteLine(color);
Console.WriteLine(visible);
Console.WriteLine();
//***** Exemple 3 *****
// ... Test enum avec la méthode switch.
FormatTypes formatValue = FormatTypes.None;
if (IsFormat(formatValue))
{
// Ceci n'est pas atteint, car None ne renvoie pas une vraie valeur dans IsFormat.
Console.WriteLine("Error");
}
// ... Testez une autre énumération avec switch.
formatValue = FormatTypes.ItalicsFormat;
if (IsFormat(formatValue))
{
// Ceci est imprimé, car nous recevons true de IsFormat.
Console.WriteLine("True");
}
Console.WriteLine();
//Affiche :
//True
//***********************************************************
// ***** recupere un Char defini dans l'enum *****
CharTypes charEnum = CharTypes.AnoniemNIETActive;
Console.WriteLine("{0}: {1}", (char)charEnum, charEnum);
Console.WriteLine();
//Affiche :
//R : AnoniemNIETActive
// ***** recupere un string defini dans l'enum *****
ColorTypes colorType = ColorTypes.Bleu;
Console.WriteLine(colorType);
Console.WriteLine("string : " + colorType + ", " + "Valeur : " + (int)colorType);
Console.WriteLine();
//Affiche :
//Bleu
//string : Bleu, Valeur : 33
//ou
foreach (var item in Enum.GetNames(typeof(ColorTypes)).ToList())
{
Console.WriteLine(item);
}
Console.WriteLine();
//Affiche :
//Rouge
//Vert
//Bleu
// ***** recupere les valeurs defini dans l'enum *****
foreach (int item in Enum.GetValues(typeof(ColorTypes)))
{
Console.WriteLine(item);
}
Console.WriteLine();
//Affiche :
//0
//1
//2
//33
foreach (int item in Enum.GetValues(typeof(CharTypes)))
{
Console.WriteLine(item);
}
Console.WriteLine();
//Affiche :
//32
//65
//82
//87
//90
Console.WriteLine((char)(int)CharTypes.Archive);
Console.WriteLine((char)CharTypes.AnoniemActive);
Console.WriteLine(CharTypes.AnoniemActive);
}
private void SetCellValueWithClickEvent(int i_Row, int i_Col, object i_Value, FormatTypes i_Type, Int32Collection i_Rows)
{
if (i_Value != null)
{
DataSet m_DBSet = this.ExControl.DataSource as DataSet;
Webb.Reports.DataProvider.VideoPlayBackArgs m_args = new Webb.Reports.DataProvider.VideoPlayBackArgs(m_DBSet, i_Rows);
(this.PrintingTable.GetCell(i_Row, i_Col) as WebbTableCell).ClickEventArg = m_args;
this.PrintingTable.GetCell(i_Row, i_Col).Text = this.FormatValue(i_Value, i_Type);
}
}
public PropertyFormatAttribute(FormatTypes type)
{
this.Type = type;
}
public RText(string record, IEnumerable <RecordMapping> mapping, string propName, FormatTypes format = FormatTypes.None)
{
int start = 0;
int length = 0;
if (mapping != null)
{
foreach (var item in mapping)
{
if (item.Field.ToLower().Equals(propName))
{
_Offset = Convert.ToInt32(item.Start);
start = Convert.ToInt32(item.Start) - 1;
length = Convert.ToInt32(item.Length);
break;
}
}
}
Parse(record, start, length, format);
}
public StringFormat GetStringFormat(FormatTypes type)
{
return(shared_formats[(int)type]);
}
public StringFormat GetStringFormat( FormatTypes type )
{
return shared_formats[(int)type];
}
