source: subversion/applications/editors/potlatch/way.as @ 7133

Last change on this file since 7133 was 7126, checked in by richard, 12 years ago

various relations fixes

File size: 23.2 KB
Line 
1
2        // =====================================================================================
3        // OOP classes - OSMWay
4
5        // ---- Initialise
6       
7        function OSMWay() {
8                this.path=new Array();
9                // path is an array of points
10                // each point is an array: (x,y,node_id,0 move|1 draw,tag array,segment id)
11                this.attr=new Array();
12                this.clean=true;                                // altered since last upload?
13                this.uploading=false;                   // currently uploading?
14                this.locked=false;                              // locked against upload?
15                this.oldversion=0;                              // is this an undeleted, not-uploaded way?
16                this.mergedways=new Array();    // list of ways merged into this
17                this.xmin=0;
18                this.xmax=0;
19                this.ymin=0;
20                this.ymax=0;
21        };
22        OSMWay.prototype=new MovieClip();
23
24        // ---- Load from remote server
25
26        OSMWay.prototype.load=function() {
27                responder = function() { };
28                responder.onResult = function(result) {
29                        _root.waysreceived+=1;
30                        var w=result[0];
31                        if (length(result[1])==0) { removeMovieClip(_root.map.ways[w]); 
32                                                                                removeMovieClip(_root.map.areas[w]); return; }
33                        var i,id;
34                        _root.map.ways[w].clean=true;
35                        _root.map.ways[w].locked=false;
36                        _root.map.ways[w].oldversion=0;
37                        _root.map.ways[w].path=result[1];
38                        _root.map.ways[w].attr=result[2];
39                        _root.map.ways[w].xmin=coord2long(result[3]);
40                        _root.map.ways[w].xmax=coord2long(result[4]);
41                        _root.map.ways[w].ymin=coord2lat(result[5]);
42                        _root.map.ways[w].ymax=coord2lat(result[6]);
43                        _root.map.ways[w].redraw();
44                        _root.map.ways[w].clearPOIs();
45                };
46                remote.call('getway',responder,Math.floor(this._name),baselong,basey,masterscale);
47        };
48
49        OSMWay.prototype.loadFromDeleted=function(version) {
50                delresponder=function() { };
51                delresponder.onResult=function(result) {
52                        var code=result.shift(); if (code) { handleError(code,result); return; }
53                        var i,z;
54                        var w=result[0];
55                        _root.map.ways[w].clean=false;
56                        _root.map.ways[w].oldversion=result[7];
57                        z=result[1]; // assign negative IDs to anything moved
58                        for (i in z) {
59                                if (result[1][i][2]<0) { _root.newnodeid--; result[1][i][2]=newnodeid; }
60                        }
61                        _root.map.ways[w].path=result[1];
62                        _root.map.ways[w].attr=result[2];
63                        _root.map.ways[w].xmin=result[3];
64                        _root.map.ways[w].xmax=result[4];
65                        _root.map.ways[w].ymin=result[5];
66                        _root.map.ways[w].ymax=result[6];
67                        if (w==wayselected) { _root.map.ways[w].select(); markClean(false); }
68                                                   else { _root.map.ways[w].locked=true; }
69                        _root.map.ways[w].redraw();
70                        _root.map.ways[w].clearPOIs();
71                };
72                remote.call('getway_old',delresponder,Math.floor(this._name),Math.floor(version),baselong,basey,masterscale);
73        };
74
75        OSMWay.prototype.clearPOIs=function() {
76                // check if any way nodes are POIs, delete the POIs if so
77                var i,z;
78                z=this.path;
79                for (i in z) {
80                        if (_root.map.pois[this.path[i][2]]) { removeMovieClip(_root.map.pois[this.path[i][2]]); }
81                }
82        };
83
84        // ---- Draw line
85
86        OSMWay.prototype.redraw=function() {
87                this.createEmptyMovieClip("line",1);                                    // clear line
88                var linewidth=3; //Math.max(2/Math.pow(2,_root.scale-13),0)+1;
89                var linealpha=100; // -50*(this.locked==true);
90               
91                // Set stroke
92
93                if              (this.locked)                                    { this.line.lineStyle(linewidth,0xFF0000,linealpha,false,"none"); }
94                else if (colours[this.attr["highway"]])  { this.line.lineStyle(linewidth,colours[this.attr["highway" ]],linealpha,false,"none"); }
95                else if (colours[this.attr["waterway"]]) { this.line.lineStyle(linewidth,colours[this.attr["waterway"]],linealpha,false,"none"); }
96                else if (colours[this.attr["railway"]])  { this.line.lineStyle(linewidth,colours[this.attr["railway" ]],linealpha,false,"none"); }
97                else {
98                        var c=0xAAAAAA; var z=this.attr;
99                        for (var i in z) { if (i!='created_by' && this.attr[i]!='' && this.attr[i].substr(0,6)!='(type ') { c=0x707070; } }
100                        this.line.lineStyle(linewidth,c,linealpha,false,"none");
101                }
102               
103                // Draw fill/casing
104
105                var f=this.getFill();
106                if ((f>-1 || casing[this.attr['highway']]) && !this.locked) {
107                        if (!_root.map.areas[this._name]) { _root.map.areas.createEmptyMovieClip(this._name,++areadepth); }
108                        with (_root.map.areas[this._name]) {
109                                clear();
110                                enabled=false;
111                                moveTo(this.path[0][0],this.path[0][1]); 
112                                if (f>-1) { beginFill(f,20); }
113                                         else { lineStyle(linewidth*1.5,0,100,false,"none"); }
114                                for (var i=1; i<this.path.length; i+=1) {
115                                        lineTo(this.path[i][0],this.path[i][1]);
116                                }
117                                if (f>-1) { endFill(); }
118                        };
119                } else if (_root.map.areas[this._name]) {
120                        removeMovieClip(_root.map.areas[this._name]);
121                }
122
123                // Draw line
124
125                this.line.moveTo(this.path[0][0],this.path[0][1]); 
126                for (var i=1; i<this.path.length; i+=1) {
127                        this.line.lineTo(this.path[i][0],this.path[i][1]);
128                }
129
130                redrawRelationsForMember('way', this._name);
131        };
132
133        OSMWay.prototype.getFill=function() {
134                var f=-1; 
135                if (this.path[this.path.length-1][0]==this.path[0][0] &&
136                        this.path[this.path.length-1][1]==this.path[0][1] &&
137                        this.path.length>2) {
138                        if (this.attr['area']) { f='0x777777'; }
139                        var z=this.attr;
140                        for (var i in z) { if (areas[i] && this.attr[i]!='' && this.attr[i]!='coastline') { f=areas[i]; } }
141                }
142                return f;
143        };
144
145        // ---- Show direction
146
147        OSMWay.prototype.direction=function() {
148                if (this.path.length<2) {
149                        _root.panel.i_circular._visible=false;
150                        _root.panel.i_direction._visible=true;
151                        _root.panel.i_direction._alpha=50;
152                } else {
153                        dx=this.path[this.path.length-1][0]-this.path[0][0];
154                        dy=this.path[this.path.length-1][1]-this.path[0][1];
155                        if (dx==0 && dy==0) {
156                                _root.panel.i_circular._visible=true;
157                                _root.panel.i_direction._visible=false;
158                        } else {
159                                _root.panel.i_direction._rotation=180-Math.atan2(dx,dy)*(180/Math.PI)-45;
160                                _root.panel.i_direction._alpha=100;
161                                _root.panel.i_direction._visible=true;
162                                _root.panel.i_circular._visible=false;
163                        }
164                }
165        };
166
167        // ---- Remove from server
168       
169        OSMWay.prototype.remove=function() {
170                this.deleteMergedWays();
171                memberDeleted('way', this._name);
172                if (this._name>=0 && !_root.sandbox && this.oldversion==0) {
173                        deleteresponder = function() { };
174                        deleteresponder.onResult = function(result) {
175                                var code=result.shift(); if (code) { handleError(code,result); return; }
176                                if (wayselected==result[0]) { deselectAll(); }
177                                removeMovieClip(_root.map.ways[result[0]]);
178                                removeMovieClip(_root.map.areas[result[0]]);
179                        };
180                        remote.call('deleteway',deleteresponder,_root.usertoken,Math.floor(this._name));
181                } else {
182                        if (this._name==wayselected) { stopDrawing(); deselectAll(); }
183                        removeMovieClip(_root.map.areas[this._name]);
184                        removeMovieClip(this);
185                }
186        };
187
188        // ---- Upload to server
189       
190        OSMWay.prototype.upload=function() {
191                putresponder=function() { };
192                putresponder.onResult=function(result) {
193                        var code=result.shift(); if (code) { handleError(code,result); return; }
194                        var i,r,z,nw,qway,qs;
195                        nw=result[1];   // new way ID
196                        if (result[0]!=nw) {
197                                _root.map.ways[result[0]]._name=nw;
198                                renumberMemberOfRelation('way', result[0], nw);
199                                if (_root.map.areas[result[0]]) { _root.map.areas[result[0]]._name=nw; }
200                                if (_root.panel.t_details.text==result[0]) { _root.panel.t_details.text=nw; _root.panel.t_details.setTextFormat(plainText); }
201                                if (wayselected==result[0]) { selectWay(nw); }
202                        }
203                        _root.map.ways[nw].xmin=result[3];
204                        _root.map.ways[nw].xmax=result[4];
205                        _root.map.ways[nw].ymin=result[5];
206                        _root.map.ways[nw].ymax=result[6];
207                        _root.map.ways[nw].uploading=false;
208                        _root.map.ways[nw].oldversion=0;
209
210                        // check if renumbered nodes occur in any other ways
211                        for (qway in _root.map.ways) {
212                                for (qs=0; qs<_root.map.ways[qway]["path"].length; qs+=1) {
213                                        if (result[2][_root.map.ways[qway].path[qs][2]]) {
214                                                _root.map.ways[qway].path[qs][2]=result[2][_root.map.ways[qway].path[qs][2]];
215                                        }
216                                }
217                        }
218                        // check if renumbered nodes are part of relations
219                        for ( var oid in result[2] ) {
220                                var nid = result[2][oid];
221                                renumberMemberOfRelation('node', oid, nid);
222                        }
223                        _root.map.ways[nw].clearPOIs();
224                        _root.map.ways[nw].deleteMergedWays();
225                };
226                if (!this.uploading && !this.locked && !_root.sandbox && this.path.length>1) {
227                        this.attr['created_by']=_root.signature;
228                        this.uploading=true;
229                        remote.call('putway',putresponder,_root.usertoken,Math.floor(this._name),this.path,this.attr,this.oldversion,baselong,basey,masterscale);
230                        this.clean=true;
231                }
232        };
233
234        // ---- Delete any ways merged into this one
235
236        OSMWay.prototype.deleteMergedWays=function() {
237                while (this.mergedways.length>0) {
238                        var i=this.mergedways.shift();
239                        _root.map.ways.attachMovie("way",i,++waydepth); // can't remove unless the movieclip exists!
240                        _root.map.ways[i].remove();
241                }
242        };
243
244        // ---- Revert to copy in database
245       
246        OSMWay.prototype.reload=function() {
247                _root.waysrequested+=1;
248                while (this.mergedways.length>0) {
249                        var i=this.mergedways.shift();
250                        _root.waysrequested+=1;
251                        _root.map.ways.attachMovie("way",i,++waydepth);
252                        _root.map.ways[i].load();
253                }
254                this.load();
255        };
256
257        // ---- Click handling 
258
259        OSMWay.prototype.onRollOver=function() {
260                if (this._name!=_root.wayselected && _root.drawpoint>-1) {
261                        this.highlightPoints(5001,"anchorhint");
262                        setPointer('penplus');
263                } else if (_root.drawpoint>-1) { setPointer('penplus'); }
264                                                                  else { setPointer(''); }
265        };
266       
267        OSMWay.prototype.onRollOut=function() {
268                if (_root.wayselected) { setPointer(''   ); }
269                                                  else { setPointer('pen'); }
270                _root.map.anchorhints.removeMovieClip();
271        };
272       
273        OSMWay.prototype.onPress=function() {
274                if (Key.isDown(Key.SHIFT) && this._name==_root.wayselected && _root.drawpoint==-1) {
275                        // shift-click current way: insert point
276                        _root.pointselected=insertAnchorPoint(this._name);
277                        this.highlightPoints(5000,"anchor");
278                        _root.map.anchors[pointselected].beginDrag();
279                } else if (Key.isDown(Key.SHIFT) && _root.wayselected && this.name!=_root.wayselected && _root.drawpoint==-1) {
280                        // shift-click other way: merge two ways
281                        var selstart =_root.ws.path[0][2];
282                        var sellen   =_root.ws.path.length-1;
283                        var selend   =_root.ws.path[sellen][2];
284                        var thisstart=_root.map.ways[this._name ].path[0][2];
285                        var thislen  =_root.map.ways[this._name ].path.length-1;
286                        var thisend  =_root.map.ways[this._name ].path[thislen][2];
287                        if      (selstart==thisstart) { _root.ws.mergeWay(0,_root.map.ways[this._name],0); }
288                        else if (selstart==thisend  ) { _root.ws.mergeWay(0,_root.map.ways[this._name],thislen); }
289                        else if (selend  ==thisstart) { _root.ws.mergeWay(sellen,_root.map.ways[this._name],0); }
290                        else if (selend  ==thisend  ) { _root.ws.mergeWay(sellen,_root.map.ways[this._name],thislen); }
291                        else                                              { return; }
292                        _root.ws.redraw();
293//                      _root.ws.upload();
294//                      _root.map.ways[this._name ].remove(wayselected);
295                        _root.ws.select();
296                } else if (_root.drawpoint>-1) {
297                        // click other way while drawing: insert point as junction
298                        if (this.oldversion==0) {
299                                if (this._name==_root.wayselected && _root.drawpoint>0) {
300                                        _root.drawpoint+=1;     // inserting node earlier into the way currently being drawn
301                                }
302                                insertAnchorPoint(this._name);
303                                this.highlightPoints(5001,"anchorhint");
304                                addEndPoint(_root.map._xmouse,_root.map._ymouse,newnodeid);
305                        }
306                        _root.junction=true;
307                        restartElastic();
308                } else {
309                        // click way: select
310                        this.select();
311                        clearTooltip();
312                }
313        };
314       
315        // ---- Select/highlight
316       
317        OSMWay.prototype.select=function() {
318                if (_root.wayselected!=this._name || _root.poiselected!=0) { uploadSelected(); }
319                _root.panel.properties.saveAttributes();
320                selectWay(this._name);
321                _root.pointselected=-2;
322                _root.poiselected=0;
323                this.highlightPoints(5000,"anchor");
324                removeMovieClip(_root.map.anchorhints);
325                this.highlight();
326                setTypeText("Way",this._name);
327                _root.panel.properties.init('way',getPanelColumns(),4);
328                _root.panel.presets.init(_root.panel.properties);
329                updateButtons();
330                updateScissors(false);
331        };
332       
333        OSMWay.prototype.highlight=function() {
334                _root.map.createEmptyMovieClip("highlight",5);
335                if (_root.pointselected>-2) {
336                        highlightSquare(_root.map.anchors[pointselected]._x,_root.map.anchors[pointselected]._y,8/Math.pow(2,Math.min(_root.scale,17)-13));
337                } else {
338                        var linewidth=11;
339                        var linecolour=0xFFFF00; if (this.locked) { var linecolour=0x00FFFF; }
340                        _root.map.highlight.lineStyle(linewidth,linecolour,80,false,"none");
341                        _root.map.highlight.moveTo(this.path[0][0],this.path[0][1]);
342                        for (var i=1; i<this.path.length; i+=1) {
343                                _root.map.highlight.lineTo(this.path[i][0],this.path[i][1]);
344                        }
345                }
346                this.direction();
347        };
348
349        OSMWay.prototype.highlightPoints=function(d,atype) {
350                anchorsize=120/Math.pow(2,_root.scale-13);
351                group=atype+"s";
352                _root.map.createEmptyMovieClip(group,d);
353                for (var i=0; i<this.path.length; i+=1) {
354                        _root.map[group].attachMovie(atype,i,i);
355                        _root.map[group][i]._x=this.path[i][0];
356                        _root.map[group][i]._y=this.path[i][1];
357                        _root.map[group][i]._xscale=anchorsize;
358                        _root.map[group][i]._yscale=anchorsize;
359                        _root.map[group][i].node=this.path[i][2];
360                        _root.map[group][i].way=this._name;
361                }
362        };
363
364        // ---- Split, merge, reverse
365
366        OSMWay.prototype.splitWay=function() {
367                var i,z;
368                if (pointselected>0 && pointselected<(this.path.length-1) && this.oldversion==0) {
369                        _root.newwayid--;                                                                                       // create new way
370                        _root.map.ways.attachMovie("way",newwayid,++waydepth);          //  |
371
372                        z=this.path;                                                                                            // copy path array
373                        for (i in z) {                                                                                          //  | (deep copy)
374                                _root.map.ways[newwayid].path[i]=new Array();                   //  |
375                                for (j=0; j<=5; j+=1) { _root.map.ways[newwayid].path[i][j]=this.path[i][j]; }
376                        }                                                                                                                       // |
377                        z=this.attr; for (i in z) { _root.map.ways[newwayid].attr[i]=z[i]; }
378
379                        z=getRelationsForWay(this._name);                                                       // copy relations
380                        for (i in z) {                                                                                          //  |
381                                _root.map.relations[z[i]].setWayRole(newwayid,_root.map.relations[z[i]].getWayRole(this._name));
382                        }                                                                                                                       //  |
383
384                        this.path.splice(Math.floor(pointselected)+1);                          // current way
385                        this.redraw();                                                                                          //  |
386
387                        _root.map.ways[newwayid].path.splice(0,pointselected);          // new way
388                        _root.map.ways[newwayid].locked=this.locked;                            //  |
389                        _root.map.ways[newwayid].redraw();                                                      //  |
390                        _root.map.ways[newwayid].upload();                                                      //  |
391
392                        this.upload();                                                                                          // upload current way
393                        pointselected=-2;                                                                                       //  |
394                        this.select();                                                                                          //  |
395                        uploadDirtyRelations();
396                };
397        };
398
399        //              Merge (start/end of this way,other way object,start/end of other way)
400        // ** needs to not add duplicate points
401
402        OSMWay.prototype.mergeWay=function(topos,otherway,frompos) {
403                var i,z;
404                if (this.oldversion>0 || otherway.oldversion>0) { return; }
405
406                if (frompos==0) { for (i=0; i<otherway.path.length;    i+=1) { this.addPointFrom(topos,otherway,i); } }
407                                   else { for (i=otherway.path.length-1; i>=0; i-=1) { this.addPointFrom(topos,otherway,i); } }
408
409                z=otherway.attr;
410                for (i in z) {
411                        if (otherway.attr[i].substr(0,6)=='(type ') { otherway.attr[i]=null; }
412                        if (this.attr[i].substr(0,6)=='(type ') { this.attr[i]=null; }
413                        if (this.attr[i]!=null) {
414                                if (this.attr[i]!=otherway.attr[i] && otherway.attr[i]!=null) { this.attr[i]+='; '+otherway.attr[i]; }
415                        } else {
416                                this.attr[i]=otherway.attr[i];
417                        }
418                        if (!this.attr[i]) { delete this.attr[i]; }
419                }
420
421                z=getRelationsForWay(otherway._name);                                           // copy relations
422                for (i in z) {                                                                                          //  |
423                        if (!_root.map.relations[z[i]].hasWay(this._name)) {    //  |
424                                _root.map.relations[z[i]].setWayRole(this._name,_root.map.relations[z[i]].getWayRole(otherway._name));
425                        }                                                                                                               //  |
426                }                                                                                                                       //  |
427
428                this.mergedways.push(otherway._name);
429                this.mergedways.concat(otherway.mergedways);
430                this.clean=false;
431                markClean(false);
432                if (otherway.locked) { this.locked=true; }
433                removeMovieClip(_root.map.areas[otherway._name]);
434                removeMovieClip(otherway);
435                if (this._name==_root.wayselected) { 
436                        _root.panel.properties.reinit();
437                }
438        };
439        OSMWay.prototype.addPointFrom=function(topos,otherway,srcpt) {
440                if (topos==0) { if (this.path[0                                 ][2]==otherway.path[srcpt][2]) { return; } }    // don't add duplicate points
441                                 else { if (this.path[this.path.length-1][2]==otherway.path[srcpt][2]) { return; } }    //  |
442                var newpoint=new Array(otherway.path[srcpt][0],
443                                                           otherway.path[srcpt][1],
444                                                           otherway.path[srcpt][2],null,
445                                                           otherway.path[srcpt][4]);
446                if (topos==0) { this.path.unshift(newpoint); }
447                             else { this.path.push(newpoint); }
448        };
449
450        // ---- Reverse order
451       
452        OSMWay.prototype.reverseWay=function() {
453                if (this.path.length<2) { return; }
454                if (_root.drawpoint>-1) { _root.drawpoint=(this.path.length-1)-_root.drawpoint; }
455                this.path.reverse();
456                this.redraw();
457                this.direction();
458                this.select();
459                this.clean=false;
460                markClean(false);
461        };
462
463        Object.registerClass("way",OSMWay);
464
465
466        // =====================================================================================
467        // Drawing support functions
468
469        // insertAnchorPoint            - add point into way with SHIFT-clicking
470       
471        function insertAnchorPoint(way) {
472                var nx,ny,closest,closei,i,x1,y1,x2,y2,direct,via,newpoint;
473                nx=_root.map._xmouse;   // where we're inserting it
474                ny=_root.map._ymouse;   //      |
475                closest=0.05; closei=0;
476                for (i=0; i<(_root.map.ways[way].path.length)-1; i+=1) {
477                        x1=_root.map.ways[way].path[i][0];
478                        y1=_root.map.ways[way].path[i][1];
479                        x2=_root.map.ways[way].path[i+1][0];
480                        y2=_root.map.ways[way].path[i+1][1];
481                        direct=Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
482                        via   =Math.sqrt((nx-x1)*(nx-x1)+(ny-y1)*(ny-y1));
483                        via  +=Math.sqrt((nx-x2)*(nx-x2)+(ny-y2)*(ny-y2));
484                        if (Math.abs(via/direct-1)<closest) {
485                                closei=i+1;
486                                closest=Math.abs(via/direct-1);
487                        }
488                }
489                _root.newnodeid--;
490                newpoint=new Array(nx,ny,newnodeid,1,new Array(),0);
491                _root.map.ways[way].path.splice(closei,0,newpoint);
492                _root.map.ways[way].clean=false;
493                _root.map.ways[way].redraw();
494                markClean(false);
495                return closei;
496        }
497
498        // startNewWay  - create new way with first point x,y,node
499
500        function startNewWay(x,y,node) {
501                uploadSelected();
502                _root.newwayid--;
503                newpoint=new Array(x,y,node,0,new Array(),0);
504                selectWay(newwayid);
505                _root.poiselected=0;
506                _root.map.ways.attachMovie("way",newwayid,++waydepth);
507                _root.map.ways[newwayid].path[0]=newpoint;
508                _root.map.ways[newwayid].redraw();
509                _root.map.ways[newwayid].select();
510                _root.map.ways[newwayid].clean=false;
511                _root.map.anchors[0].startElastic();
512                _root.drawpoint=0;
513                markClean(false);
514                setTooltip("click to add point\ndouble-click/Return\nto end line",0);
515        }
516
517        // addEndPoint - add point to start/end of line
518
519        function addEndPoint(x,y,node,tags) {
520                if (tags) {} else { tags=new Array(); }
521                newpoint=new Array(x,y,node,0,tags,0);
522                x1=_root.ws.path[_root.drawpoint][0];
523                y1=_root.ws.path[_root.drawpoint][1];
524                if (_root.drawpoint==_root.ws.path.length-1) {
525                        _root.ws.path.push(newpoint);
526                        _root.drawpoint=_root.ws.path.length-1;
527                } else {
528                        _root.ws.path.unshift(newpoint);        // drawpoint=0, add to start
529                }
530       
531                // Redraw line (if possible, just extend it to save time)
532                if (_root.ws.getFill()>-1 || 
533                        _root.ws.path.length<3 ||
534                        _root.pointselected>-2) {
535                        _root.ws.redraw();
536                        _root.ws.select();
537                } else {
538                        _root.ws.line.moveTo(x1,y1);
539                        _root.ws.line.lineTo(x,y);
540                        if (casing[_root.ws.attr['highway']]) {
541                                _root.map.areas[wayselected].moveTo(x1,y1);
542                                _root.map.areas[wayselected].lineTo(x,y);
543                        }
544                        _root.map.highlight.moveTo(x1,y1);
545                        _root.map.highlight.lineTo(x,y);
546                        _root.ws.direction();
547                        _root.ws.highlightPoints(5000,"anchor");
548                        removeMovieClip(_root.map.anchorhints);
549                }
550                redrawRelationsForMember('way',_root.wayselected);
551                // Mark as unclean
552                _root.ws.clean=false;
553                markClean(false);
554                _root.map.elastic.clear();
555        }
556
557        function stopDrawing() {
558                _root.map.anchors[_root.drawpoint].endElastic();
559                _root.drawpoint=-1;
560                if (_root.ws.path.length<=1) { 
561                        // way not long enough, so abort
562                        removeMovieClip(_root.map.areas[wayselected]);
563                        removeMovieClip(_root.ws);
564                        removeMovieClip(_root.map.anchors);
565                }
566                _root.map.elastic.clear();
567                clearTooltip();
568        };
569
570        // cycleStacked - cycle through ways sharing same point
571
572        function cycleStacked() {
573                if (_root.pointselected>-2) {
574                        var id=_root.ws.path[_root.pointselected][2];
575                        var firstfound=0; var nextfound=0;
576                        for (qway in _root.map.ways) {
577                                if (qway!=_root.wayselected) {
578                                        for (qs=0; qs<_root.map.ways[qway]["path"].length; qs+=1) {
579                                                if (_root.map.ways[qway].path[qs][2]==id) {
580                                                        var qw=Math.floor(qway);
581                                                        if (firstfound==0 || qw<firstfound) { firstfound=qw; }
582                                                        if ((nextfound==0 || qw<nextfound) && qw>wayselected) { nextfound=qw; }
583                                                }
584                                        }
585                                }
586                        }
587                        if (firstfound) {
588                                if (nextfound==0) { var nextfound=firstfound; }
589                                _root.map.ways[nextfound].swapDepths(_root.ws);
590                                _root.map.ways[nextfound].select();
591                        }
592                }
593        };
594
595        // ================================================================
596        // Way communication
597       
598        // whichWays    - get list of ways from remoting server
599
600        function whichWays() {
601                _root.lastwhichways=new Date();
602                if (_root.waycount>500) { purgeWays(); }
603                if (_root.poicount>500) { purgePOIs(); }
604                if (_root.edge_l>_root.bigedge_l &&
605                        _root.edge_r<_root.bigedge_r &&
606                        _root.edge_b>_root.bigedge_b &&
607                        _root.edge_t<_root.bigedge_t) {
608                        // we have already loaded this area, so ignore
609                } else {
610                        whichresponder=function() {};
611                        whichresponder.onResult=function(result) {
612                                _root.whichreceived+=1;
613                                waylist  =result[0];
614                                pointlist=result[1];
615                                relationlist=result[2];
616
617                                for (i in waylist) {                                                                            // ways
618                                        way=waylist[i];                                                                                 //  |
619                                        if (!_root.map.ways[way]) {                                                             //  |
620                                                _root.map.ways.attachMovie("way",way,++waydepth);       //  |
621                                                _root.map.ways[way].load();                                                     //  |
622                                                _root.waycount+=1;                                                                      //  |
623                                                _root.waysrequested+=1;                                                         //  |
624                                        }
625                                }
626                               
627                                for (i in pointlist) {                                                                          // POIs
628                                        point=pointlist[i][0];                                                                  //  |
629                                        if (!_root["map"]["pois"][point]) {                                             //  |
630                                                _root.map.pois.attachMovie("poi",point,++poidepth);     //  |
631                                                _root.map.pois[point]._x=pointlist[i][1];                       //  |
632                                                _root.map.pois[point]._y=pointlist[i][2];                       //  |
633                                                _root.map.pois[point]._xscale=
634                                                _root.map.pois[point]._yscale=Math.max(100/Math.pow(2,_root.scale-13),6.25);
635                                                _root.map.pois[point].attr=pointlist[i][3];                     //  |
636                                                _root.poicount+=1;                                                                      //  |
637                                        }
638                                }
639
640                                for (i in relationlist) {
641                                        rel = relationlist[i];
642                    if (!_root.map.relations[rel]) {
643                                                _root.map.relations.attachMovie("relation",rel,++reldepth);
644                                                _root.map.relations[rel].load();
645                                                _root.relcount+=1;
646                                                _root.relsrequested+=1;
647                                        }
648                }
649                        };
650                        remote.call('whichways',whichresponder,_root.edge_l,_root.edge_b,_root.edge_r,_root.edge_t,baselong,basey,masterscale);
651                        _root.bigedge_l=_root.edge_l; _root.bigedge_r=_root.edge_r;
652                        _root.bigedge_b=_root.edge_b; _root.bigedge_t=_root.edge_t;
653                        _root.whichrequested+=1;
654                }
655        }
656
657        // purgeWays - remove any clean ways outside current view
658       
659        function purgeWays() {
660                for (qway in _root.map.ways) {
661                        if (qway==_root.wayselected) {
662                        } else if (!_root.map.ways[qway].clean) {
663                                _root.map.ways[qway].upload();
664                                uploadDirtyRelations();
665                        } else if (((_root.map.ways[qway].xmin<edge_l && _root.map.ways[qway].xmax<edge_l) ||
666                                                (_root.map.ways[qway].xmin>edge_r && _root.map.ways[qway].xmax>edge_r) ||
667                                            (_root.map.ways[qway].ymin<edge_b && _root.map.ways[qway].ymax<edge_b) ||
668                                                (_root.map.ways[qway].ymin>edge_t && _root.map.ways[qway].ymax>edge_t))) {
669                                removeMovieClip(_root.map.ways[qway]);
670                                removeMovieClip(_root.map.areas[qway]);
671                                _root.waycount-=1;
672                        }
673                }
674                _root.bigedge_l=_root.edge_l; _root.bigedge_r=_root.edge_r;
675                _root.bigedge_b=_root.edge_b; _root.bigedge_t=_root.edge_t;
676        }
677
678        function selectWay(id) {
679                _root.wayselected=Math.floor(id);
680                _root.ws=_root.map.ways[id];
681        }
Note: See TracBrowser for help on using the repository browser.