public override void getSize(Node containerNode)
{
int d = 0;
float dpi = base.painter_.DpiX();
float f = base.painter_.FontSize(containerNode, containerNode.style_);
base.rect.width = AttributeBuilder.SizeByAttr(f, dpi, containerNode, "width", this.width);
base.rect.height = AttributeBuilder.SizeByAttr(f, dpi, containerNode, "height", this.height);
d = AttributeBuilder.SizeByAttr(f, dpi, containerNode, "depth", this.depth);
if (base.rect.height == 0)
{
base.rect.height = 2;
}
if (base.rect.width == 0)
{
base.rect.width = 2;
}
if (d == 0)
{
base.rect.baseline = base.rect.height / 2;
}
else if (d > base.rect.height)
{
base.rect.height += d;
base.rect.baseline = 0;
}
else
{
base.rect.baseline = base.rect.height - d;
}
}
public override void getSize(Node containerNode)
{
BoxRect boxRect;
this.attrs = AttributeBuilder.QuoteAttributes(containerNode);
if (containerNode.numChildren <= 0)
{
if ((containerNode.literalText != null) && (containerNode.literalText.Length > 0))
{
base.painter_.MeasureBox(containerNode, containerNode.style_);
}
else
{
base.painter_.MeasureBox(containerNode, containerNode.style_, "X");
}
}
if (this.attrs != null)
{
if (this.attrs.lquote != "NONE")
{
this.leftQuote = this.attrs.lquote;
}
else
{
this.leftQuote = "";
}
if (this.attrs.rquote != "NONE")
{
this.rightQuote = this.attrs.rquote;
}
else
{
this.rightQuote = "";
}
}
else
{
this.leftQuote = "\"";
this.rightQuote = "\"";
}
if (this.leftQuote.Length > 0)
{
boxRect = base.painter_.MeasureTextRect(containerNode, this.leftQuote, containerNode.scriptLevel_, containerNode.style_);
this.leftQuoteWidth = boxRect.width;
}
else
{
this.leftQuoteWidth = 0;
}
if (this.leftQuote.Length > 0)
{
boxRect = base.painter_.MeasureTextRect(containerNode, this.rightQuote, containerNode.scriptLevel_, containerNode.style_);
this.rightQuoteWidth = boxRect.width;
}
else
{
this.rightQuoteWidth = 0;
}
base.rect.width += this.leftQuoteWidth + this.rightQuoteWidth;
}
/// <summary>
/// Write out the current contents of the AttributeBuilder
/// </summary>
/// <returns></returns>
protected string FlushAttributeBuilder()
{
var result = AttributeBuilder.GetContents();
AttributeBuilder = null;
return(result);
}
/// <summary>
/// 单表分页数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queryColumns">要查询字段</param>
/// <param name="sortColumn">排序字段</param>
/// <param name="sortType">排序方式</param>
/// <param name="pageSize">每页条数</param>
/// <param name="pageIndex">第几页</param>
/// <param name="whereSql">过滤条件Sql</param>
/// <param name="whereParam">过滤条件字段名及字段值参数,例:new {Uname="joyet",Age = 110}</param>
/// <returns></returns>
public override DbEntity QueryPageList <T>(string queryColumns, string sortColumn, string sortType, long pageSize, long pageIndex, string whereSql, object whereParam)
{
DbEntity dbEntity = null;
Type type = typeof(T);
var attributeBuilder = new AttributeBuilder();
var tableEntity = attributeBuilder.GetTableInfo(type);
dbEntity = new DbEntity()
{
TableEntity = tableEntity
};
var startNum = pageSize * (pageIndex - 1);
var dbOperator = DbFactory.GetDbParamOperator();
List <TableColumnAttribute> whereColumns = attributeBuilder.GetColumnInfos(whereParam);
var dbParams = new List <IDbDataParameter>();
//分页查询模板
var queryTemplate = @"select {queryColumns} from
(
select {sortColumn} from {tableName} {whereCriteria} order by {sortColumn} {sortType} limit {pageSize} offset {startNum}
)
a inner join {tableName} b on a.{sortColumn}=b.{sortColumn} order by b.{sortColumn} {sortType};";
StringBuilder sqlBuild = new StringBuilder(queryTemplate);
sqlBuild.Replace("{sortColumn}", sortColumn);
sqlBuild.Replace("{tableName}", tableEntity.TableName);
sqlBuild.Replace("{sortType}", sortType);
sqlBuild.Replace("{startNum}", startNum.ToString());
sqlBuild.Replace("{pageSize}", pageSize.ToString());
HandleQueryColumParam(queryColumns, "b", ref sqlBuild);
HandleWhereParam(whereSql, whereColumns, ref sqlBuild, ref dbParams);
dbEntity.CommandText = sqlBuild.ToString();
dbEntity.DbParams = dbParams;
return(dbEntity);
}
/// <summary>
/// Create an AttributeBuilder if it doesn't already exist to start writing attributes to it
/// </summary>
protected void EnsureAttributeBuilder()
{
if (AttributeBuilder == null)
{
AttributeBuilder = new AttributeBuilder();
}
}
public void TestNodeSeparator()
{
_builder = new AttributeBuilder(":", ",");
_builder.Add("a", "1");
_builder.Add("b", "2");
Assert.AreEqual("a:\"1\",b:\"2\"", _builder.GetResult());
}
private static void VisitMethodCall(AttributeBuilder builder, MethodCallExpression method, Expression valueExpression, FilterOperator filterOperator)
{
var value = Expression.Lambda(valueExpression).Compile().DynamicInvoke();
var memberExpression = GetMemberAccessExpression(builder, method.Object);
builder.AddAttribute(GetName(memberExpression.Member), filterOperator, value);
}
private static void VisitBinaryMemberAccess(AttributeBuilder builder, BinaryExpression binary, FilterOperator filterOperator)
{
Expression valueExpression = null;
var memberExpression = GetMemberAccessExpression(builder, binary.Left);
if (memberExpression == null)
{
valueExpression = binary.Left;
memberExpression = GetMemberAccessExpression(builder, binary.Right);
if (memberExpression == null)
{
// no member was found..so assume one of the values is an attribute name.
var attributeName = Expression.Lambda(binary.Left).Compile().DynamicInvoke();
var attributeValue = Expression.Lambda(binary.Right).Compile().DynamicInvoke();
builder.AddAttribute(Convert.ToString(attributeName), filterOperator, EscapeCharacters(attributeValue));
return;
}
}
else
{
valueExpression = binary.Right;
}
var value = Expression.Lambda(valueExpression).Compile().DynamicInvoke();
builder.AddAttribute(GetName(memberExpression.Member), filterOperator, EscapeCharacters(value));
}
private static void VisitExpression(AttributeBuilder builder, Expression expression)
{
if (expression.NodeType.Is(DirectoryExpressionType.Where))
{
VisitLambda(builder, ((WhereExpression)expression).Where);
}
else if (expression.NodeType.Is(ExpressionType.Lambda))
{
VisitLambda(builder, (LambdaExpression)expression);
}
else if (expression is BinaryExpression)
{
VisitBinary(builder, (BinaryExpression)expression);
}
else if (expression.NodeType.Is(ExpressionType.MemberAccess))
{
VisitMember(builder, (MemberExpression)expression);
}
else if (expression.NodeType.Is(ExpressionType.Constant))
{
VisitConstant(builder, (ConstantExpression)expression);
}
else if (expression.NodeType.Is(ExpressionType.Call))
{
VisitMethod(builder, (MethodCallExpression)expression);
}
else
{
throw new NotSupportedException();
}
}
public void BuildAccordingToAttribute()
{
IAttributedBuilder builder = new AttributeBuilder();
new Director().BuildUp(builder);
Assert.AreEqual <string>("a", builder.Log[0]);
Assert.AreEqual <string>("b", builder.Log[1]);
Assert.AreEqual <string>("c", builder.Log[2]);
}
public void 特性_T1()
{
AttributeBuilder builder = CodeSyntax.CreateAttribute("Key");
var result = builder.ToFormatCode();
#if Log
_tempOutput.WriteLine(result.WithUnixEOL());
#endif
Assert.Equal("Key", result.WithUnixEOL());
}
private static void VisitLambda(AttributeBuilder builder, LambdaExpression lambda)
{
if (lambda.Body is BinaryExpression)
{
VisitBinary(builder, (BinaryExpression)lambda.Body);
}
else if (lambda.Body is MethodCallExpression)
{
VisitMethod(builder, (MethodCallExpression)lambda.Body);
}
}
public void 特性_T3()
{
AttributeBuilder builder = CodeSyntax.CreateAttribute("DisplayName")
.WithProperty(new string[] { "Name = \"a\"" });
var result = builder.ToFormatCode();
#if Log
_tempOutput.WriteLine(result.WithUnixEOL());
#endif
Assert.Equal(@"DisplayName(Name = ""a"")", result.WithUnixEOL());
}
public MCell(MRow row, Node node, int index)
{
this.rowAlign = RowAlign.UNKNOWN;
this.columnAlign = HAlign.UNKNOWN;
this.columnSpan = 1;
this.rowSpan = 1;
this.colSpan = 0;
this.tableAttrs = AttributeBuilder.FromNode(node);
this.row_ = row;
this.node = node;
this.colSpan = index;
}
public void 特性_T2()
{
AttributeBuilder builder = CodeSyntax.CreateAttribute("DisplayName")
.WithCtor("666");
var result = builder.ToFormatCode();
#if Log
_tempOutput.WriteLine(result.WithUnixEOL());
#endif
Assert.Equal("DisplayName(666)", result.WithUnixEOL());
}
static string TranslateKnownTypesAttribute(KnownTypesAttribute a)
{
var translation = new StringBuilder();
foreach (var type in a.KnownTypes)
{
string attrText =
new AttributeBuilder(typeof(KnownTypesAttribute).FullName)
.AddTypeParam(type.GetNonGenericName())
.ToString();
translation.AppendLine(attrText);
}
return translation.ToString();
}
static void Main(string[] args)
{
IAttributeBuilder builder = new AttributeBuilder();
Director director = new Director();
director.BuilUp(builder);
Console.WriteLine(builder.Log[0]);
// Console.WriteLine(builder.Log[1]);
Console.Read();
}
public void GenderTest()
{
var genderAttr = AttributeBuilder.Create("Gender")
.Salted(false).SetPosition(2).SetSize(1).SetCreation(2).SetMaxRange(2).Build();
var dict = new Dictionary <int, int>();
foreach (var b1 in Base58Encoding.Digits.ToCharArray())
{
foreach (var b2 in Base58Encoding.Digits.ToCharArray())
{
var addr = "M" + b1 + b2 + "KtKS3AeNuRFWE5Qj9tFiNAahWvQMTiz";
var pubMogAddressHex = HexHashUtil.ByteArrayToString(Base58Encoding.Decode(addr));
var hexValue =
new HexValue(
new Shift(0,
1530914381,
pubMogAddressHex,
7234,
"00000000090d6c6b058227bb61ca2915a84998703d4444cc2641e6a0da4ba37e",
2,
"163d2e383c77765232be1d9ed5e06749a814de49b4c0a8aebf324c0e9e2fd1cf",
1.00m,
0.0001m));
genderAttr.CreateValue(hexValue);
var value = genderAttr.GetValue();
var orgValue = HexHashUtil.GetHexVal(pubMogAddressHex[1]);
if (dict.TryGetValue(value, out var count))
{
dict[value] = count + 1;
}
else
{
dict.Add(value, 1);
}
}
}
Assert.Equal(2, dict.Count);
var enumerator = dict.Keys.GetEnumerator();
enumerator.MoveNext();
Assert.Equal(1, enumerator.Current);
enumerator.MoveNext();
Assert.Equal(0, enumerator.Current);
Assert.Equal(1692, dict[0]);
Assert.Equal(1672, dict[1]);
}
/// <summary>
/// 添加一个枚举字段，比为字段添加特性
/// </summary>
/// <param name="code"></param>
/// <param name="func">特性</param>
/// <returns></returns>
public virtual TBuilder WithField(string code, Action <AttributeBuilder> func)
{
if (string.IsNullOrEmpty(code))
{
throw new ArgumentNullException(nameof(code));
}
AttributeBuilder builder = new AttributeBuilder();
func.Invoke(builder);
_enum.Fields.Add($"{builder.ToFullCode()}\n{code}");
return(_TBuilder);
}
public override IEnumerable<string> GetAttributesTextFor(Type settingsType)
{
var attributesText = base.GetAttributesTextFor(settingsType);
if (settingsType.IsDefined<RootAttribute>())
{
string xmlRootAttribute =
new AttributeBuilder(typeof(XmlRootAttribute).FullName)
.AddStringParam("Namespace", GetXmlNamesapceForRootType(settingsType))
.ToString();
attributesText = attributesText.Append(xmlRootAttribute);
}
return attributesText;
}
public MRow(MTable matrix, Node node, int index)
{
this.isLabeled = false;
this.index = 0;
this.align = RowAlign.UNKNOWN;
this.spacing = "0.5ex";
this.lines = TableLineStyle.NONE;
this.index = index;
this.attrs = AttributeBuilder.MRowAttributes(node);
this.colAligns = new HAlign[] { HAlign.UNKNOWN };
this.matrix = matrix;
this.node = node;
this.cells = new ArrayList();
}
/// <summary>
/// Query paging data based on query fields, filtering conditions, filtering parameters, sorting conditions, number of pages per page, and current page number.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queryColumns"></param>
/// <param name="whereSql"></param>
/// <param name="whereObjParams"></param>
/// <param name="sortCriteria"></param>
/// <param name="pageSize"></param>
/// <param name="pageIndex"></param>
/// <returns></returns>
public override DbEntity QueryPageList <T>(string queryColumns, string whereSql, object whereParam, string sortCriteria, int pageSize, int pageIndex)
{
DbEntity dbEntity = null;
if (string.IsNullOrEmpty(queryColumns))
{
return(dbEntity);
}
Type type = typeof(T);
var attributeBuilder = new AttributeBuilder();
var tableEntity = attributeBuilder.GetTableInfo(type);
dbEntity = new DbEntity()
{
DbType = DbFactory.DbType,
TableEntity = tableEntity
};
int startNum = pageSize * (pageIndex - 1);
int endNum = pageSize * pageIndex;
string dbOperator = DbFactory.GetDbOperator();
var pkColumn = attributeBuilder.GetPkColumnInfo(type);
if (pkColumn == null)
{
return(dbEntity);
}
List <TableColumnAttribute> whereColumns = attributeBuilder.GetColumnInfos(whereParam);
var dbParams = new List <IDbDataParameter>();
//Paging query template
StringBuilder sqlBuild = new StringBuilder("select {queryColumns} from {tableName} a,");
sqlBuild.Append("(");
sqlBuild.Append("select {pkColumn} from {tableName} {whereCriteria} order by {sortCriteria} limit {startNum},{Num}");
sqlBuild.Append(")");
sqlBuild.Append(" b where a.{pkColumn}=b.{pkColumn} ");
sqlBuild.Append("order by a.{sortCriteria};");
sqlBuild.Replace("{tableName}", tableEntity.TableName);
sqlBuild.Replace("{pkColumn}", pkColumn.ColumnName);
sqlBuild.Replace("{sortCriteria}", sortCriteria);
sqlBuild.Replace("{startNum}", startNum.ToString());
sqlBuild.Replace("{Num}", pageSize.ToString());
HandleQuerColumns(queryColumns, "a", ref sqlBuild, ref dbParams);
HandleWhereParam(whereSql, whereColumns, ref sqlBuild, ref dbParams);
dbEntity.CommandText = sqlBuild.ToString();
dbEntity.DbParams = dbParams;
return(dbEntity);
}
/// <summary>
/// 单表分页数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queryColumns">要查询字段</param>
/// <param name="sortColumn">排序字段</param>
/// <param name="sortType">排序方式</param>
/// <param name="pageSize">每页条数</param>
/// <param name="pageIndex">第几页</param>
/// <param name="whereSql">过滤条件Sql</param>
/// <param name="whereParam">过滤条件字段名及字段值参数,例:new {Uname="joyet",Age = 110}</param>
/// <returns></returns>
public override DbEntity QueryPageList <T>(string queryColumns, string sortColumn, string sortType, int pageSize, int pageIndex, string whereSql, object whereParam)
{
DbEntity dbEntity = null;
dbEntity = base.QueryPageList <T>(queryColumns, sortColumn, sortType, pageSize, pageIndex, whereSql, whereParam);
if (dbEntity == null)
{
return(dbEntity);
}
var type = typeof(T);
var attributeBuilder = new AttributeBuilder();
var tableEntity = attributeBuilder.GetTableInfo(type);
dbEntity.TableEntity = tableEntity;
var startNum = pageSize * (pageIndex - 1);
var dbOperator = DbFactory.GetDbParamOperator();
var whereColumns = attributeBuilder.GetColumnInfos(whereParam);
var dbParams = new List <IDbDataParameter>();
//分页查询模板
var sqlBuilder = new StringBuilder();
sqlBuilder.AppendLine("select {queryColumns} from");
sqlBuilder.AppendLine("(");
sqlBuilder.AppendLine("select {sortColumn} from {tableName} {whereCriteria} order by {sortColumn} {sortType} limit {startNum},{pageSize}");
sqlBuilder.AppendLine(")");
sqlBuilder.AppendLine("a inner join {tableName} b on a.{sortColumn}=b.{sortColumn} order by b.{sortColumn} {sortType}");
sqlBuilder.Replace("{sortColumn}", sortColumn);
sqlBuilder.Replace("{tableName}", tableEntity.TableName);
sqlBuilder.Replace("{sortType}", sortType);
sqlBuilder.Replace("{startNum}", startNum.ToString());
sqlBuilder.Replace("{pageSize}", pageSize.ToString());
//处理查询字段参数
var queryColumnItem = HandleQueryColumnParam(queryColumns, "b", sqlBuilder);
sqlBuilder = queryColumnItem.Item1;
//处理过滤字段参数
var whereItem = HandleWhereParam(whereSql, whereColumns, sqlBuilder, dbParams);
sqlBuilder = whereItem.Item1;
dbParams = whereItem.Item2;
dbEntity.CommandText = sqlBuilder.ToString();
dbEntity.DbParams = dbParams;
return(dbEntity);
}
/// <summary>
/// 单实体分页数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queryColumns"></param>
/// <param name="whereSql"></param>
/// <param name="sortCriteria"></param>
/// <param name="pageSize"></param>
/// <param name="pageIndex"></param>
/// <param name="whereObjParams"></param>
/// <returns></returns>
public override DbEntity QueryPageList <T>(string queryColumns, string whereSql, string sortColumn, string sortType, long pageSize, long pageIndex, object whereObjParams)
{
DbEntity dbEntity = null;
if (string.IsNullOrEmpty(sortColumn) || string.IsNullOrEmpty(sortType))
{
return(dbEntity);
}
if (pageSize <= 0 || pageIndex <= 0)
{
return(dbEntity);
}
Type type = typeof(T);
var attributeBuilder = new AttributeBuilder();
var tableEntity = attributeBuilder.GetTableInfo(type);
dbEntity = new DbEntity()
{
TableEntity = tableEntity
};
var startNum = pageSize * (pageIndex - 1) + 1;
var endNum = pageSize * pageIndex;
var dbOperator = DbFactory.GetDbParamOperator();
List <TableColumnAttribute> whereColumns = attributeBuilder.GetColumnInfos(whereObjParams);
var dbParams = new List <IDbDataParameter>();
//分页查询模板
var queryTemplate = @"select {queryColumns} from
(
select {sortColumn},ROW_NUMBER() over(order by {sortColumn} {sortType}) num from {tableName} {whereCriteria} order by {sortColumn} {sortType}
)
a inner join {tableName} b on a.{sortColumn}=b.{sortColumn} and a.num between {startNum} and {endNum} order by b.{sortColumn} {sortType};";
StringBuilder sqlBuild = new StringBuilder(queryTemplate);
sqlBuild.Replace("{sortColumn}", sortColumn);
sqlBuild.Replace("{tableName}", tableEntity.TableName);
sqlBuild.Replace("{sortType}", sortType);
sqlBuild.Replace("{startNum}", startNum.ToString());
sqlBuild.Replace("{endNum}", endNum.ToString());
sqlBuild.Replace("{pageSize}", pageSize.ToString());
HandleQueryParam(queryColumns, "b", ref sqlBuild);
HandleWhereParam(whereSql, whereColumns, ref sqlBuild, ref dbParams);
dbEntity.CommandText = sqlBuild.ToString();
dbEntity.DbParams = dbParams;
return(dbEntity);
}
static void Main(string[] args)
{
AttributeBuilder builder = CodeSyntax.CreateAttribute("Key");
var result = builder.ToFormatCode();
Console.WriteLine(result);
//var a = DependencyContext.Default.CompileLibraries;
//var b = a.Count;
//foreach (var item in DependencyContext.Default.CompileLibraries.SelectMany(cl=>cl.ResolveReferencePaths()))
//{
// Console.WriteLine(item);
//}
//GenericBuilder generic = new GenericBuilder();
//generic.AddConstarint(new GenericScheme("T1", GenericConstraintsType.Struct));
//generic.AddConstarint(new GenericScheme("T2", GenericConstraintsType.Class));
//generic.AddConstarint(new GenericScheme("T3", GenericConstraintsType.Notnull));
//generic.AddConstarint(new GenericScheme("T4", GenericConstraintsType.Unmanaged));
//generic.AddConstarint(new GenericScheme("T5", GenericConstraintsType.New));
//// 如果能够反射拿到 Type
//generic.AddConstarint(new GenericScheme("T6", GenericConstraintsType.BaseClass, typeof(int)));
//// 如果要以字符串定义基类类型，请使用 此API
//generic.AddBaseClassConstarint("T7", " IEnumerable<int>");
//generic.AddTUConstarint("T8", "T2");
//generic.AddConstarint(new GenericScheme("T9", GenericConstraintsType.Class, GenericConstraintsType.New));
//var syntax = generic.Build();
//var result = syntax.ToFullString();
//Console.WriteLine(result);
//ClassBuilder buidler = new ClassBuilder();
//var build = buidler.SetVisibility(ClassVisibilityType.Public)
// .SetName("Test")
// .AddMethodMember(b =>
// {
// b.SetVisibility(MemberVisibilityType.Public)
// .SetRondomName()
// .SetBlock("System.Console.WriteLine(\"111\");");
// })
// .Build();
//CompilationBuilder compilation = new CompilationBuilder();
//compilation.Test(build);
Console.ReadKey();
}
public Node ParseMstyle(XmlNode XMLNode, Types mTypes, EntityManager mEntities, bool bAll, StyleAttributes styleAttributes)
{
StyleAttributes s = null;
if ((XMLNode.Attributes == null) || (XMLNode.Attributes.Count <= 0))
{
return(Parse(XMLNode, mTypes, mEntities, bAll, styleAttributes, true));
}
Node node = new Node();
node.type_ = mTypes["mstyle"];
node.attrs = new AttributeList();
for (int i = 0; i < XMLNode.Attributes.Count; i++)
{
node.attrs.Add(new Attribute(XMLNode.Attributes[i].Name, XMLNode.Attributes[i].Value, ""));
}
StyleAttributes fromNode = new StyleAttributes();
s = new StyleAttributes();
fromNode = AttributeBuilder.StyleAttrsFromNode(node, true);
if (fromNode != null)
{
if (styleAttributes != null)
{
node.style_ = new StyleAttributes();
fromNode.CopyTo(node.style_);
node.style_.canOverride = true;
s = node.CascadeOverride(styleAttributes);
}
else
{
fromNode.CopyTo(s);
}
}
else
{
if (styleAttributes != null)
{
styleAttributes.CopyTo(s);
}
}
s.canOverride = true;
XMLNode.Attributes.RemoveAll();
return(Parse(XMLNode, mTypes, mEntities, bAll, s, true));
}
public static ClassDeclarationSyntax Build(string Code, string[] attrs = null)
{
ClassDeclarationSyntax memberDeclaration;
memberDeclaration = CSharpSyntaxTree.ParseText(Code)
.GetRoot()
.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.Single();
if (attrs != null)
{
memberDeclaration = memberDeclaration
.WithAttributeLists(AttributeBuilder.CreateAttributeList(attrs));
}
return(memberDeclaration);
}
public void ProcessToken()
{
Content.Append(";");
bool parsingString = false;
bool parseName = false;
bool parseAttribute = false;
for (int i = 0; i < Content.Length - 1; i++)
{
char c = Content[i];
char c1 = Content[i + 1];
if (c == '"')
{
parsingString = !parsingString;
}
if (!parsingString && (c == '<' || c == '/') && char.IsLetter(c1))
{
parseName = true;
}
if (parseName)
{
if (c == ' ')
{
parseAttribute = true;
}
if (parseAttribute)
{
AttributeBuilder.Append(c);
}
else
{
if (!parsingString && c == '/' || c == '<' || c == '>')
{
continue;
}
NameBuilder.Append(c);
}
}
}
}
public FractionsPropertiesDialog(Node node)
{
this.success_ = false;
this.container = null;
this.InitializeComponent();
if (node.box != null)
{
this.FractionAttrs = AttributeBuilder.FractionAttrsFromNode(node);
if (this.FractionAttrs != null)
{
this.isBevelled_.Checked = this.FractionAttrs.isBevelled;
this.lineThick.Value = (decimal)this.FractionAttrs.lineThickness;
if (this.FractionAttrs.numAlign == FractionAlign.LEFT)
{
this.numalignLeft_.Checked = true;
}
else if (this.FractionAttrs.numAlign == FractionAlign.CENTER)
{
this.numalignCenter_.Checked = true;
}
else if (this.FractionAttrs.numAlign == FractionAlign.RIGHT)
{
this.numalignRight_.Checked = true;
}
if (this.FractionAttrs.denomAlign == FractionAlign.LEFT)
{
this.denomalignLeft_.Checked = true;
}
else if (this.FractionAttrs.denomAlign == FractionAlign.CENTER)
{
this.denomAlignCenter_.Checked = true;
}
else if (this.FractionAttrs.denomAlign == FractionAlign.RIGHT)
{
this.denomalignRight_.Checked = true;
}
}
else
{
this.FractionAttrs = new FractionAttributes();
}
}
}
private static void VisitMethod(AttributeBuilder builder, MethodCallExpression method)
{
var methodInfo = method.Method;
if (methodInfo.DeclaringType == typeof(string) && (methodInfo.CallingConvention & CallingConventions.HasThis) == CallingConventions.HasThis)
{
switch (methodInfo.Name)
{
case "StartsWith":
{
if (method.Arguments.Count == 1)
{
VisitMethodCall(builder, method, method.Arguments[0], FilterOperator.StartsWith);
}
break;
}
case "EndsWith":
{
if (method.Arguments.Count == 1)
{
VisitMethodCall(builder, method, method.Arguments[0], FilterOperator.EndsWith);
}
break;
}
case "Contains":
{
if (method.Arguments.Count == 1)
{
VisitMethodCall(builder, method, method.Arguments[0], FilterOperator.Contains);
}
break;
}
default:
{
throw new NotSupportedException(string.Format(Properties.Resources.MethodNotSupported, methodInfo.Name));
}
}
}
}
private static MemberExpression GetMemberAccessExpression(AttributeBuilder builder, Expression expression)
{
if (expression.NodeType.Is(ExpressionType.MemberAccess))
{
// Commented out by Stephen for the purpose of an anonomous object in the query.
// Example:
// var query = new { Cn = string.Empty };
// Users.Where(u => query.Cn == "My Name");
//MemberExpression memberExpression = (MemberExpression)expression;
//if (memberExpression.Member.DeclaringType == builder.Parent.GetObjectClassType())
//{
// return memberExpression;
//}
// End comment by Stephen
return((MemberExpression)expression);
}
return(null);
}
public override void setChildSize(Node childNode)
{
if (childNode.childIndex == 0)
{
this.isFenced = false;
this.attrs = AttributeBuilder.FencedAttrsFromNode(childNode.parent_);
if (this.attrs != null)
{
if (this.IsFence(this.attrs.open) || this.IsFence(this.attrs.close))
{
this.isFenced = true;
}
}
else
{
this.isFenced = true;
}
this.baseline = base.painter_.MeasureBaseline(childNode.parent_, childNode.parent_.style_, "X");
this.leading = (int)Math.Round((double)(this.baseline * 0.4));
}
base.rect.width += childNode.box.Width;
if (childNode.prevSibling != null)
{
base.rect.width += this.SeparatorWidth(childNode);
}
if (childNode.box.Baseline > base.rect.baseline)
{
base.rect.baseline = childNode.box.Baseline;
}
if ((childNode.box.Height - childNode.box.Baseline) > base.rect.accent)
{
base.rect.accent = childNode.box.Height - childNode.box.Baseline;
}
base.rect.height = base.rect.baseline + base.rect.accent;
base.Skip(childNode, true);
}
/// <summary>
/// Json属性生成器
/// </summary>
public JsonAttributeBuilder()
{
_builder = new AttributeBuilder( ":","," );
}
public void TestAttributeSeparator() {
_builder = new AttributeBuilder(":");
_builder.Add( "class", "a" );
Assert.AreEqual( "class:\"a\"", _builder.GetResult() );
}
public void TestNodeSeparator() {
_builder = new AttributeBuilder( ":","," );
_builder.Add( "a", "1" );
_builder.Add( "b", "2" );
Assert.AreEqual( "a:\"1\",b:\"2\"", _builder.GetResult() );
}
/// <summary>
/// 初始化EasyUi属性生成器
/// </summary>
public EasyUiAttributeBuilder()
{
_dataOptionBuilder = new AttributeBuilder( ":", "," );
}
public void TestInit() {
_builder = new AttributeBuilder();
}
