source: subversion/applications/editors/potlatch/undo.as @ 20427

Last change on this file since 20427 was 19957, checked in by richard, 10 years ago

duplicate nodes stuff

File size: 8.0 KB
RevLine 
[7658]1
2        // =====================================================================================
3        // undo.as
4        // Potlatch undo stack code
5        // =====================================================================================
6
7        function UndoStack() {
8                this.sp=0;
9        };
10
11        UndoStack.prototype=new Array();
12
13        UndoStack.prototype.append=function(task,params,tooltip) {
14                // add to stack
15                if (_root.undoing) { return; }
16                this[this.sp]=new Array(task,params,tooltip); this.sp++;
17                this.setTooltip(tooltip);
18        };
19
20        UndoStack.prototype.rollback=function() {
[17662]21                if (_root.undoing) { return; }          // Stop any routines from adding to the undo stack
[7658]22                if (this.sp==0) { return; }
[17662]23                _root.undoing=true;
[7658]24                var popped=this[this.sp-1];                     // Same as this.pop, but works :)
25                this.sp--;                                                      //      |
26                popped[0].call(this,popped[1]);
27                if (this.sp)     { this.setTooltip(this[this.sp-1][2]); }
28                                        else { this.setTooltip(""); }
29                _root.undoing=false;                            // Permit adding to undo stack
30        };
31
32        UndoStack.prototype.setTooltip=function(str) {
33                if (str=='') {
[17776]34                        _root.panel.i_undo.onRollOver=function() { setFloater(iText('tip_noundo')); };
[7718]35                        _root.panel.i_undo._alpha=50;
[7658]36                } else {
[17776]37                        _root.panel.i_undo.onRollOver=function() { setFloater(iText('tip_undo',str)); };
[7718]38                        _root.panel.i_undo._alpha=100;
[7658]39                }
40        };
41       
42        UndoStack.prototype.clear=function() { this.sp=0; };
43
[15136]44
[7658]45        // ---- Individual undo methods
46       
47        //              Added point into way
48
49        UndoStack.prototype.undo_addpoint=function(params) {
50                var waylist=params[0]; var poslist=params[1]; var w;
51                for (var i in waylist) {
52                        w=waylist[i];
53                        w.removeAnchorPoint(poslist[i]);
[7718]54                        w.clean=false;
[7658]55                }
56                w.select();
[7718]57                stopDrawing();
[7658]58        };
59
60        //              Moved node
61       
62        UndoStack.prototype.undo_movenode=function(params) {
[8894]63                var nodecopy=params[0];
64                var w=_root.nodes[nodecopy.id].moveTo(nodecopy.x,nodecopy.y,null);
[7718]65                if (w) { 
66                        _root.map.ways[w].clean=false;
67                        _root.map.ways[w].select();
68                }
[7658]69        };
70       
71        //              Merged ways
72
73        UndoStack.prototype.undo_mergeways=function(params) {
74                var way=params[0];
75                if (way) {
76                        way.attr=params[1];
77                        way.splitWay(params[3],params[2]);
78                } else {
[17776]79                        handleError(-1,new Array(iText('error_noway',way.id)));
[7658]80                        this.clear();
81                }
82        };
83
84        //              Split way
85
86        UndoStack.prototype.undo_splitway=function(params) {
87                var way1=params[0]; var way2=params[1];
88                if (way1.mergeAtCommonPoint(way2)) {
89                        way2.redraw(); way2.select();
90                } else {
[17776]91                        handleError(-1,new Array(iText('error_nosharedpoint',way1.id,way2.id)));
[7658]92                        this.clear();
93                }
94        };
95
96        //              Changed tags
97        //              ** to do - relations support
98       
99        UndoStack.prototype.undo_waytags=function(params) {
100                var way=params[0]; if (!way) {
[17776]101                        handleError(-1,new Array(iText('error_noway',way.id)));
[7658]102                        this.clear(); return;
103                } else {
104                        way.attr=params[1];
[7718]105                        way.clean=false;
[7658]106                        way.redraw();
107                        way.select();
108                }
109        };
110        UndoStack.prototype.undo_pointtags=function(params) {
111                var way=params[0]; var point=params[1]; if (!way) {
[17776]112                        handleError(-1,new Array(iText('error_noway',way.id)));
[7658]113                        this.clear(); return;
114                } else {
[10776]115                        way.path[point].attr=params[2];
[12386]116                        way.path[point].markDirty();
[7718]117                        way.clean=false;
[7658]118                        way.select(); _root.map.anchors[point].select();
119                }
120        };
121        UndoStack.prototype.undo_poitags=function(params) {
122                var poi=params[0]; if (!poi) {
[17776]123                        handleError(-1,new Array(iText('error_nopoi')));
[7658]124                        this.clear(); return;
125                } else {
126                        poi.attr=params[1];
[7718]127                        poi.clean=false;
[7658]128                        poi.select();
129                }
130        };
131       
132        //              Removed point from way(s) (at x,y,tags if it no longer exists)
133
134        UndoStack.prototype.undo_deletepoint=function(params) {
[8894]135                var last;
136                var nodecopy=params[0]; var id=nodecopy.id;
137                var waylist=params[1];
138                var poslist=params[2];
139
140                // create node if no longer in existence
[15136]141                if (!_root.nodes[id]) {
142                        newnodeid--; id=newnodeid;
143                        _root.nodes[id]=new Node(id,nodecopy.x,nodecopy.y,nodecopy.attr,nodecopy.version);
144                }
[8894]145
[7658]146                // reinstate at each place
147                for (qway in waylist) {
148                        last=waylist[qway];     // select last one
[10776]149                        _root.nodes[id].addWay(last);
150                        _root.map.ways[last].path.splice(poslist[qway],0,_root.nodes[id]);
151                        _root.map.ways[last].clean=false;
152                        _root.map.ways[last].redraw();
[14830]153                        var z=_root.map.ways[last].deletednodes; delete z[id];
[7658]154                }
[7718]155                stopDrawing();
[7658]156                _root.map.ways[last].select();
157        };
158
159        //              Moved POI
160
161        UndoStack.prototype.undo_movepoi=function(params) {
162                var poi=params[0]; if (!poi) {
[17776]163                        handleError(-1,new Array(iText('error_nopoi')));
[7658]164                        this.clear(); return;
165                } else {
166                        poi._x=params[1]; poi._y=params[2];
167                        poi.clean=false; poi.select();
168                }
169        };
170
[7718]171        //              Moved way (and any nodes used in other ways)
172
173        UndoStack.prototype.undo_movenodes=function(params) {
174                var way=params[0]; if (!way) {
[17776]175                        handleError(-1,new Array(iText('error_noway',way.id)));
[7718]176                        this.clear(); return;
177                } else {
178                        way.moveNodes(-params[1],-params[2]);
179                        way.redraw();
180                        way.select();
181                }
182        };
183
184        //              Reversed way
185
186        UndoStack.prototype.undo_reverse=function(params) {
187                var way=params[0]; if (!way) {
[17776]188                        handleError(-1,new Array(iText('error_noway',way.id)));
[7718]189                        this.clear(); return;
190                } else {
191                        way.reverseWay();
192                }
193        };
194
[7658]195        //              Deleted POI
[7718]196
197        UndoStack.prototype.undo_deletepoi=function(params) {
[15136]198                var poi=params[0]; newnodeid--;
[7718]199                stopDrawing();
[15136]200                if (_root.map.pois[newnodeid]) {} else {
201                        _root.map.pois.attachMovie("poi",newnodeid,++poidepth);
[7718]202                }
[15136]203                _root.map.pois[newnodeid]._x=params[1];
204                _root.map.pois[newnodeid]._y=params[2];
205                _root.map.pois[newnodeid].attr=params[3];
206                _root.map.pois[newnodeid].select();
207                _root.map.pois[newnodeid].clean=false;
[7718]208                markClean(false);
209        };
[7658]210       
[7718]211        //              Deleted way
[7658]212
[7718]213        UndoStack.prototype.undo_deleteway=function(params) {
[16865]214                var w;
215                if (_root.sandbox) { w=params[0]; }
216                                          else { w=newwayid--; }
[7718]217                stopDrawing();
[16865]218                _root.map.ways.attachMovie("way",w,++waydepth);
219                _root.map.ways[w]._x=params[1];
220                _root.map.ways[w]._y=params[2];
221                _root.map.ways[w].attr=params[3];
[17662]222                if (_root.sandbox) { _root.map.ways[w].path=restorepath(params[4],w); delete _root.waystodelete[w]; }
[16865]223                                          else { _root.map.ways[w].path=renumberDeleted(params[4],params[0],w); }
224                _root.map.ways[w].version=params[5];
225                _root.map.ways[w].redraw();
226                _root.map.ways[w].select();
227                _root.map.ways[w].clean=false;
[7718]228                markClean(false);
229        };
[7658]230
[16388]231        //              Changed path (for tidying)
232
233        UndoStack.prototype.undo_changeway=function(params) {
234                var way=params[0]; var w=_root.map.ways[way];
[17662]235                w.path=restorepath(params[1],way);
236                w.deletednodes=params[2];
237                w.attr=params[3];
238                stopDrawing();
239                w.redraw();
240                w.select();
241                w.clean=false;
242                markClean(false);
243        };
244
245        function restorepath(path,way) {
[16388]246                // we need to be careful not to end up with duplicate versions of
247                // the same node
[17662]248                var returnpath=new Array();
249                var done=new Object();
[16388]250                for (var i=0; i<path.length; i++) {
[16525]251                        var id=path[i].id;
252                        if (!done[id]) {
253                                if (_root.nodes[id]) {
[19957]254                                        _root.nodes[id].unsetPosition();
[16525]255                                        _root.nodes[id].x=path[i].x;
256                                        _root.nodes[id].y=path[i].y;
257                                        _root.nodes[id].attr=path[i].attr;
258                                        _root.nodes[id].tagged=hasTags(path[i].attr);
259                                        _root.nodes[id].version=path[i].version;
260                                        _root.nodes[id].clean=false;
[19957]261                                        _root.nodes[id].setPosition();
[16525]262                                        _root.nodes[id].addWay(way);
263                                } else {
264                                        _root.nodes[id]=deepCopy(path[i]);
[19957]265                                        _root.nodes[id].setPosition();
[16525]266                                }
267                                if (_root.nodes[id].numberOfWays()>1) {
268                                        _root.nodes[id].redrawWays();
269                                }
270                        }
[17662]271                        returnpath.push(_root.nodes[id]);
[16525]272                        done[id]=true;
[16388]273                }
[17662]274                return returnpath;
275        }
[16388]276
[17662]277
[7718]278        //              Created POI
[7658]279
[7718]280        UndoStack.prototype.undo_createpoi=function(params) {
281                poi=params[0]; poi.remove();
282                markClean(false);
283        };
[11420]284       
285        //              Created ways (e.g. parallel)
286       
287        UndoStack.prototype.undo_makeways=function(params) {
288                for (i in params) { _root.map.ways[params[i]].remove(); }
289        };
[7718]290
291
[15136]292        // ---- renumberDeleted - give new ids to any nodes with only one way (i.e. deleted)
[7658]293
[15136]294        function renumberDeleted(path,oldway,newway) {
295                for (var i in path) {
296                        if (path[i].numberOfWays()==1 && path[i].ways[oldway]) {
297                                newnodeid--;
298                                path[i].id=newnodeid;
299                                path[i].version=0; path[i].clean=false;
300                                path[i].ways=new Object(); path[i].ways[newway]=true;
301                                _root.nodes[newnodeid]=path[i]; // path[i].renumberTo(newnodeid);
302                        } else {
303                                var z=path[i].ways; delete z[oldway]; z[newway]=true;
304                                _root.nodes[path[i].id]=path[i];
305                        }
306                }
307                return path;
308        }
Note: See TracBrowser for help on using the repository browser.