提交 | 用户 | age
|
25ab64
|
1 |
// ----------------------------------------------------------------------------------------------------------- |
F |
2 |
// Functions for creating included child rows, when children count exceeds MaxChildren |
|
3 |
// ----------------------------------------------------------------------------------------------------------- |
|
4 |
MS.CPages; |
|
5 |
// ----------------------------------------------------------------------------------------------------------- |
|
6 |
// Adds and returns automatic child page |
|
7 |
// If show is set, adds body also to html and interconnects them |
|
8 |
TGP.AddCPage = function(par,server){ |
|
9 |
var B = Dom.createElement("B"); |
|
10 |
par.appendChild(B); |
|
11 |
if(par.Page) { |
|
12 |
B.Def = this.Def["R"]; |
|
13 |
var empty = 1; |
|
14 |
} |
|
15 |
else { |
|
16 |
var RA = Grids.INames; |
|
17 |
for(var c in par) if(!RA[c]) B[c] = par[c]; |
|
18 |
var empty = this.EmptyChildPages||this.MaxChildrenEmpty; |
|
19 |
} |
|
20 |
var CP = this.Def[server?"SPage":"CPage"]; |
|
21 |
if(CP){ |
|
22 |
var N = {"Name":1,"Def":1,"id":1}; |
|
23 |
N.Updated = 1; |
|
24 |
for(var c in CP) if(!N[c]) B[c] = CP[c]; |
|
25 |
} |
|
26 |
if(!server) B.CPage = 1; |
|
27 |
if(B.AggChildren==null) B.AggChildren = 1; |
|
28 |
B.Level = par.Level+1; |
|
29 |
B.CanEdit = 0; |
|
30 |
if(B.Expanded==null) B.Expanded = 0; |
|
31 |
if(B.Visible==null) B.Visible = 0; |
|
32 |
B.State = server ? 0 : 2; |
|
33 |
B.CanDelete = 0; |
|
34 |
B.CanSelect = 0; |
|
35 |
B.CanCopy = 0; |
|
36 |
B.Selected = 0; |
|
37 |
B.CanDrag = 0; |
|
38 |
|
|
39 |
for(var i=this.FirstSec;i<=this.LastSec;i++) B['r'+i] = null; |
|
40 |
|
|
41 |
if(!B.Visible) for(var c in this.Cols){ |
|
42 |
B[c+"CanEdit"] = 0; |
|
43 |
B[c+"Button"] = ""; |
|
44 |
B[c+"Icon"] = ""; |
|
45 |
if(empty) B[c+"Visible"]=0; |
|
46 |
|
|
47 |
} |
|
48 |
if(empty) B[this.MainCol+"Visible"] = 1; |
|
49 |
if(this.SetIds) { |
|
50 |
B.id = this.ChildIdPrefix+this.ChildAutoId++; |
|
51 |
while(this.Rows[B.id]) B.id = this.ChildIdPrefix+this.ChildAutoId++; |
|
52 |
this.Rows[B.id] = B; |
|
53 |
} |
|
54 |
|
|
55 |
return B; |
|
56 |
} |
|
57 |
// ----------------------------------------------------------------------------------------------------------- |
|
58 |
// Deletes page even from HTML |
|
59 |
TGP.DelCPage = function(B){ |
|
60 |
|
|
61 |
var ch = B.State==4 && B.firstChild, next = this.ReversedTree ? "previousSibling" : "nextSibling"; |
|
62 |
for(var i=this.FirstSec;i<=this.LastSec;i++){ |
|
63 |
var r = B["r"+i]; |
|
64 |
if(!r) continue; |
|
65 |
var p = r.parentNode; |
|
66 |
if(ch) p.removeChild(r[next]); |
|
67 |
p.removeChild(r); |
|
68 |
} |
|
69 |
|
|
70 |
var par = B.parentNode; |
|
71 |
par.removeChild(B); |
|
72 |
B.Removed = 1; |
|
73 |
if(B.id) delete this.Rows[B.id]; |
|
74 |
if(!par.firstChild) { |
|
75 |
par.CDef = B.CDef; |
|
76 |
par.AcceptDef = B.AcceptDef; |
|
77 |
} |
|
78 |
} |
|
79 |
// ----------------------------------------------------------------------------------------------------------- |
|
80 |
// Creates child pages for given body or XB, recursion |
|
81 |
TGP.CreateAllCPages = function(par,show){ |
|
82 |
if(par==this.XB){ |
|
83 |
if(!this.MainCol) return; |
|
84 |
for(var r=par.firstChild;r;r=r.nextSibling) this.CreateAllCPages(r,show); |
|
85 |
} |
|
86 |
else if(par.Page){ |
|
87 |
for(var r=par.firstChild;r;r=r.nextSibling) if(r.firstChild) this.CreateCPages(r,show,null,1); |
|
88 |
} |
|
89 |
else this.CreateCPages(par,show,null,1); |
|
90 |
} |
|
91 |
// ----------------------------------------------------------------------------------------------------------- |
|
92 |
// Creates child page for given row |
|
93 |
// A can be array of children or null - it is created |
|
94 |
TGP.CreateCPages = function(par,show,A,recurse){ |
|
95 |
|
|
96 |
var max = par.Page?1e10 : Get(par,"MaxChildren"), fc = par.firstChild, cnt=0, res = par.Page ? 0 : Get(par,"MaxChildrenDiff"); |
|
97 |
if(!A){ |
|
98 |
if(!fc || !par.Visible && !par.Page) return; |
|
99 |
if(fc.CPage){ |
|
100 |
A = []; |
|
101 |
for(var pr=par.firstChild,p=0;pr;pr=pr.nextSibling){ |
|
102 |
for(var r=pr.firstChild;r;r=r.nextSibling){ |
|
103 |
A[p++] = r; |
|
104 |
if(r.Visible) cnt++; |
|
105 |
if(recurse && r.firstChild) this.CreateCPages(r,show,null,1); |
|
106 |
} |
|
107 |
} |
|
108 |
} |
|
109 |
else { |
|
110 |
var len = par.childNodes.length; |
|
111 |
if(len>max+res) { |
|
112 |
A = []; |
|
113 |
for(var r=par.firstChild,p=0;r;r=r.nextSibling){ |
|
114 |
A[p++] = r; |
|
115 |
if(r.Visible) cnt++; |
|
116 |
if(recurse && r.firstChild) this.CreateCPages(r,show,null,1); |
|
117 |
} |
|
118 |
} |
|
119 |
else { |
|
120 |
cnt = len; |
|
121 |
if(recurse) for(var r=par.firstChild;r;r=r.nextSibling) if(r.firstChild) this.CreateCPages(r,show,null,1); |
|
122 |
} |
|
123 |
} |
|
124 |
} |
|
125 |
else { |
|
126 |
var len = A.length; |
|
127 |
if(len>max+res) for(var i=0;i<len;i++) if(A[i].Visible) cnt++; |
|
128 |
else cnt = len; |
|
129 |
if(recurse) for(var i=0;i<len;i++) if(A[i].firstChild) this.CreateCPages(A[i],show,null,1); |
|
130 |
} |
|
131 |
|
|
132 |
var T = this; |
|
133 |
function updatelevel(row,show){ |
|
134 |
for(var r=row.firstChild;r;r=r.nextSibling){ |
|
135 |
T.UpdateLevelImg(r,show); |
|
136 |
if(r.firstChild) updatelevel(r,show); |
|
137 |
} |
|
138 |
} |
|
139 |
|
|
140 |
if(cnt>max+res){ |
|
141 |
var nul = cnt<100 ? 2 : cnt<1000 ? 3 : 4, nulls="0000", pref = this.GetText("Items"); |
|
142 |
var cnt = 0, body, ocnt = par.childNodes.length, ogc = Grids.OnCreateCPage; |
|
143 |
par._Count = cnt; |
|
144 |
var cdef = fc.CPage ? fc.CDef : Get(par,"CDef"); |
|
145 |
var adef = fc.CPage ? fc.AcceptDef : Get(par,"AcceptDef"); |
|
146 |
for(var i=0;i<A.length;i++){ |
|
147 |
if(A[i].Visible || !body){ |
|
148 |
if(!cnt){ |
|
149 |
cnt = max; |
|
150 |
body = this.AddCPage(par); |
|
151 |
body.CDef = cdef; |
|
152 |
body.AcceptDef = adef; |
|
153 |
} |
|
154 |
cnt--; |
|
155 |
} |
|
156 |
if(show && par.Expanded && st!=3 && A[i].r1) this.TableDelRow(A[i]); |
|
157 |
body.appendChild(A[i]); |
|
158 |
A[i].Level = body.Level+1; |
|
159 |
} |
|
160 |
if(max-cnt<Get(par,"MaxChildrenMin") && body.previousSibling){ |
|
161 |
var pb = body.previousSibling; |
|
162 |
for(var p = body.firstChild,lp;p;p=lp){ lp = p.nextSibling; pb.appendChild(p); } |
|
163 |
this.DelCPage(body); |
|
164 |
} |
|
165 |
par.CDef = "*"; |
|
166 |
par.AcceptDef = "*"; |
|
167 |
if(fc.CPage) { |
|
168 |
for(var i=0,r=par.firstChild;i<ocnt&&r;i++,r=r.nextSibling) r.Visible = 0; |
|
169 |
this.HideFRow(); |
|
170 |
for(var i=0;i<ocnt;i++) this.DelCPage(par.firstChild); |
|
171 |
} |
|
172 |
|
|
173 |
var mc = this.MainCol, ln = 0, st = par.State; |
|
174 |
if(par.State==4) par.State=2; |
|
175 |
|
|
176 |
function GetStr(val){ |
|
177 |
val+=""; |
|
178 |
return nulls.slice(0,nul-val.length)+val; |
|
179 |
} |
|
180 |
var MC = this.Cols[mc], P = this.GetCalc(); |
|
181 |
this.Rendering = 1; |
|
182 |
for(var r=par.firstChild;r;r=r.nextSibling){ |
|
183 |
|
|
184 |
for(var c=r.firstChild,lnc=0;c;c=c.nextSibling) if(c.Visible) lnc++; |
|
185 |
|
|
186 |
if(r.Calculated) this.CalcRow(r,P,"CalcOrder",show); |
|
187 |
r[mc+"Type"] = "Html"; |
|
188 |
r[mc+"Format"] = ""; |
|
189 |
r[mc+"Wrap"] = 0; |
|
190 |
r[mc] = pref.replace(/\%d/,GetStr(ln+1)).replace(/\%d/,GetStr(ln+lnc)); |
|
191 |
r.Hasch = 2; |
|
192 |
if(ogc) Grids.OnCreateCPage(this,r); |
|
193 |
if(show && par.Expanded && st!=3){ |
|
194 |
this.ShowRow(r); |
|
195 |
this.RefreshCell(r,mc); |
|
196 |
} |
|
197 |
r.Visible = 1; |
|
198 |
ln += lnc; |
|
199 |
} |
|
200 |
this.Rendering = 0; |
|
201 |
this.Update(); |
|
202 |
|
|
203 |
updatelevel(par,0); |
|
204 |
|
|
205 |
} |
|
206 |
|
|
207 |
else if(A){ |
|
208 |
if(BNN) for(var i=0;i<A.length;i++) par.removeChild(A[i]); |
|
209 |
for(var i=0;i<A.length;i++) par.appendChild(A[i]); |
|
210 |
if(fc.CPage) { |
|
211 |
for(var r=fc;r&&r.CPage;r=par.firstChild) this.DelCPage(par.firstChild); |
|
212 |
|
|
213 |
updatelevel(par,show); |
|
214 |
if(show && par.Expanded && st!=3){ |
|
215 |
var r1 = 1; |
|
216 |
for(var r=par.firstChild;r;r=r.nextSibling) if(!r.r1){ r1=0; break; } |
|
217 |
if(!r1){ |
|
218 |
this.Collapse(par); |
|
219 |
par.State=2; |
|
220 |
this.ClearChildren(par); |
|
221 |
this.Expand(par); |
|
222 |
} |
|
223 |
if(!this.HasChildren(par) || !this.CanShowChildren(par)) this.DeleteChildren(par); |
|
224 |
} |
|
225 |
this.UpdateIcon(par); |
|
226 |
} |
|
227 |
|
|
228 |
if(show) this.ShowCPages(A,fc); |
|
229 |
|
|
230 |
} |
|
231 |
} |
|
232 |
// ----------------------------------------------------------------------------------------------------------- |
|
233 |
// Updates captions all immediate CPages of given row |
|
234 |
TGP.UpdateCPages = function(par){ |
|
235 |
var cnt = 0, nul = par._Count<100 ? 2 : par._Count<1000 ? 3 : 4, nulls="0000", pref = this.GetText("Items"), mc = this.MainCol; |
|
236 |
function GetStr(val){ |
|
237 |
val+=""; |
|
238 |
return nulls.slice(0,nul-val.length)+val; |
|
239 |
} |
|
240 |
for(var r=par.firstChild;r;){ |
|
241 |
if(!r.CPage) break; |
|
242 |
var c = r.childNodes.length; |
|
243 |
if(!c){ |
|
244 |
var rx = r.nextSibling; |
|
245 |
this.DelRow(r); |
|
246 |
r = rx; |
|
247 |
continue; |
|
248 |
} |
|
249 |
var S = pref.replace(/\%d/,GetStr(cnt+1)).replace(/\%d/,GetStr(cnt+c)); |
|
250 |
if(S!=r[mc]){ |
|
251 |
r[mc] = S; |
|
252 |
this.RefreshCell(r,mc); |
|
253 |
} |
|
254 |
cnt+=c; |
|
255 |
r=r.nextSibling; |
|
256 |
} |
|
257 |
} |
|
258 |
// ----------------------------------------------------------------------------------------------------------- |
|
259 |
ME.CPages; |
|
260 |
// ----------------------------------------------------------------------------------------------------------- |
|
261 |
// Support function Sort and CPages - shows children in A in grid |
|
262 |
// fc is first child of the parent, set only for CPages |
|
263 |
MS.Tree; |
|
264 |
TGP.ShowCPages = function(A,fc){ |
|
265 |
var rev = this.ReversedTree, next = rev ? "previousSibling" : "nextSibling"; |
|
266 |
for(var j=this.FirstSec;j<=this.LastSec;j++){ |
|
267 |
var n = "r"+j, p = A[0][n]; |
|
268 |
if(p) p = p.parentNode; |
|
269 |
else { |
|
270 |
for(var i=0;i<A.length;i++) if(A[i][n]) { p = A[i][n].parentNode; break; } |
|
271 |
if(fc && fc.CPage && p) p = A[i][n][next]; |
|
272 |
} |
|
273 |
var orr = j==1 && Grids.OnDisplaceRow!=null; |
|
274 |
if(p) for(var i=0;i<A.length;i++){ |
|
275 |
if(!A[i][n]) continue; |
|
276 |
var ch = A[i].Hasch ? A[i][n][next] : null; |
|
277 |
if(ch) { |
|
278 |
if(!rev) p.appendChild(A[i][n]); |
|
279 |
p.appendChild(ch); |
|
280 |
if(rev) p.appendChild(A[i][n]); |
|
281 |
} |
|
282 |
else p.appendChild(A[i][n]); |
|
283 |
if(orr) Grids.OnDisplaceRow(this,A[i]); |
|
284 |
} |
|
285 |
} |
|
286 |
} |
|
287 |
// ----------------------------------------------------------------------------------------------------------- |
|
288 |
// ----------------------------------------------------------------------------------------------------------- |
|
289 |
TGP.CreateSPages = function(par){ |
|
290 |
if(par.firstChild) { |
|
291 |
for(var r=par.firstChild;r;r=r.nextSibling) this.CreateSPages(r); |
|
292 |
} |
|
293 |
else if(par.Count>this.ChildPageLength+this.ChildPageDiff) { |
|
294 |
for(var cnt=Math.ceil(par.Count/this.ChildPageLength),i=0;i<cnt;i++) { |
|
295 |
var r = this.AddCPage(par,1); |
|
296 |
r.Pos = i; |
|
297 |
r.SPage = 1; |
|
298 |
r.Count = i<cnt-1||!(par.Count%this.ChildPageLength) ? this.ChildPageLength : par.Count%this.ChildPageLength; |
|
299 |
} |
|
300 |
par.Count = null; |
|
301 |
} |
|
302 |
} |
|
303 |
// ----------------------------------------------------------------------------------------------------------- |
|
304 |
ME.Tree; |
|
305 |
// ----------------------------------------------------------------------------------------------------------- |