1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
//------------------------------------------------------------------------------
// <copyright file="BoundPropertyEntry.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI {
using System.Reflection;
using System.Web.Util;
using System.Web.Compilation;
using System.ComponentModel.Design;
using System.Security.Permissions;
/// <devdoc>
/// PropertyEntry for any bound properties
/// </devdoc>
public class BoundPropertyEntry : PropertyEntry {
private string _expression;
private ExpressionBuilder _expressionBuilder;
private string _expressionPrefix;
private bool _useSetAttribute;
private object _parsedExpressionData;
private bool _generated;
private string _fieldName;
private string _formatString;
private string _controlID;
private Type _controlType;
private bool _readOnlyProperty;
private bool _twoWayBound;
internal BoundPropertyEntry() {
}
/// <devdoc>
/// The id of the control that contains this binding.
/// </devdoc>
public string ControlID {
get {
return _controlID;
}
set {
_controlID = value;
}
}
/// <devdoc>
/// The type of the control which is being bound to a runtime value.
/// </devdoc>
public Type ControlType {
get {
return _controlType;
}
set {
_controlType = value;
}
}
/// <devdoc>
/// </devdoc>
public string Expression {
get {
return _expression;
}
set {
_expression = value;
}
}
public ExpressionBuilder ExpressionBuilder {
get {
return _expressionBuilder;
}
set {
_expressionBuilder = value;
}
}
public string ExpressionPrefix {
get {
return _expressionPrefix;
}
set {
_expressionPrefix = value;
}
}
/// <devdoc>
/// The name of the data field that is being bound to.
/// </devdoc>
public string FieldName {
get {
return _fieldName;
}
set {
_fieldName = value;
}
}
/// <devdoc>
/// The format string applied to the field for display.
/// </devdoc>
public string FormatString {
get {
return _formatString;
}
set {
_formatString = value;
}
}
internal bool IsDataBindingEntry {
// Empty prefix means it's a databinding expression (i.e. <%# ... %>)
get { return String.IsNullOrEmpty(ExpressionPrefix); }
}
/// <summary>
/// This represents the column value where the property value begins.
/// Currently only calculated for data bound property entries, for other type
/// of Bound Properties it has default value which is 0.
/// </summary>
internal int Column {
get;
set;
}
/// <summary>
/// This represents the line value where the property value is present.
/// Currently only calculated for data bound property entries, for other type
/// of Bound Properties it has default value which is 0.
/// </summary>
internal int Line {
get;
set;
}
public bool Generated {
get {
return _generated;
}
set {
_generated = value;
}
}
public object ParsedExpressionData {
get {
return _parsedExpressionData;
}
set {
_parsedExpressionData = value;
}
}
/// <devdoc>
/// Indicates whether the two way statement is set and get, or just get but not set.
/// </devdoc>
public bool ReadOnlyProperty {
get {
return _readOnlyProperty;
}
set {
_readOnlyProperty = value;
}
}
public bool TwoWayBound {
get {
return _twoWayBound;
}
set {
_twoWayBound = value;
}
}
/// <devdoc>
/// </devdoc>
public bool UseSetAttribute {
get {
return _useSetAttribute;
}
set {
_useSetAttribute = value;
}
}
public bool IsEncoded {
get;
set;
}
// Parse the expression, and store the resulting object
internal void ParseExpression(ExpressionBuilderContext context) {
if (Expression == null || ExpressionPrefix == null || ExpressionBuilder == null)
return;
_parsedExpressionData = ExpressionBuilder.ParseExpression(Expression, Type, context);
}
}
}
|
