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

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

duplicate nodes stuff

File size: 8.0 KB
Line 
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() {
21                if (_root.undoing) { return; }          // Stop any routines from adding to the undo stack
22                if (this.sp==0) { return; }
23                _root.undoing=true;
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=='') {
34                        _root.panel.i_undo.onRollOver=function() { setFloater(iText('tip_noundo')); };
35                        _root.panel.i_undo._alpha=50;
36                } else {
37                        _root.panel.i_undo.onRollOver=function() { setFloater(iText('tip_undo',str)); };
38                        _root.panel.i_undo._alpha=100;
39                }
40        };
41       
42        UndoStack.prototype.clear=function() { this.sp=0; };
43
44
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]);
54                        w.clean=false;
55                }
56                w.select();
57                stopDrawing();
58        };
59
60        //              Moved node
61       
62        UndoStack.prototype.undo_movenode=function(params) {
63                var nodecopy=params[0];
64                var w=_root.nodes[nodecopy.id].moveTo(nodecopy.x,nodecopy.y,null);
65                if (w) { 
66                        _root.map.ways[w].clean=false;
67                        _root.map.ways[w].select();
68                }
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 {
79                        handleError(-1,new Array(iText('error_noway',way.id)));
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 {
91                        handleError(-1,new Array(iText('error_nosharedpoint',way1.id,way2.id)));
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) {
101                        handleError(-1,new Array(iText('error_noway',way.id)));
102                        this.clear(); return;
103                } else {
104                        way.attr=params[1];
105                        way.clean=false;
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) {
112                        handleError(-1,new Array(iText('error_noway',way.id)));
113                        this.clear(); return;
114                } else {
115                        way.path[point].attr=params[2];
116                        way.path[point].markDirty();
117                        way.clean=false;
118                        way.select(); _root.map.anchors[point].select();
119                }
120        };
121        UndoStack.prototype.undo_poitags=function(params) {
122                var poi=params[0]; if (!poi) {
123                        handleError(-1,new Array(iText('error_nopoi')));
124                        this.clear(); return;
125                } else {
126                        poi.attr=params[1];
127                        poi.clean=false;
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) {
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
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                }
145
146                // reinstate at each place
147                for (qway in waylist) {
148                        last=waylist[qway];     // select last one
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();
153                        var z=_root.map.ways[last].deletednodes; delete z[id];
154                }
155                stopDrawing();
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) {
163                        handleError(-1,new Array(iText('error_nopoi')));
164                        this.clear(); return;
165                } else {
166                        poi._x=params[1]; poi._y=params[2];
167                        poi.clean=false; poi.select();
168                }
169        };
170
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) {
175                        handleError(-1,new Array(iText('error_noway',way.id)));
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) {
188                        handleError(-1,new Array(iText('error_noway',way.id)));
189                        this.clear(); return;
190                } else {
191                        way.reverseWay();
192                }
193        };
194
195        //              Deleted POI
196
197        UndoStack.prototype.undo_deletepoi=function(params) {
198                var poi=params[0]; newnodeid--;
199                stopDrawing();
200                if (_root.map.pois[newnodeid]) {} else {
201                        _root.map.pois.attachMovie("poi",newnodeid,++poidepth);
202                }
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;
208                markClean(false);
209        };
210       
211        //              Deleted way
212
213        UndoStack.prototype.undo_deleteway=function(params) {
214                var w;
215                if (_root.sandbox) { w=params[0]; }
216                                          else { w=newwayid--; }
217                stopDrawing();
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];
222                if (_root.sandbox) { _root.map.ways[w].path=restorepath(params[4],w); delete _root.waystodelete[w]; }
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;
228                markClean(false);
229        };
230
231        //              Changed path (for tidying)
232
233        UndoStack.prototype.undo_changeway=function(params) {
234                var way=params[0]; var w=_root.map.ways[way];
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) {
246                // we need to be careful not to end up with duplicate versions of
247                // the same node
248                var returnpath=new Array();
249                var done=new Object();
250                for (var i=0; i<path.length; i++) {
251                        var id=path[i].id;
252                        if (!done[id]) {
253                                if (_root.nodes[id]) {
254                                        _root.nodes[id].unsetPosition();
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;
261                                        _root.nodes[id].setPosition();
262                                        _root.nodes[id].addWay(way);
263                                } else {
264                                        _root.nodes[id]=deepCopy(path[i]);
265                                        _root.nodes[id].setPosition();
266                                }
267                                if (_root.nodes[id].numberOfWays()>1) {
268                                        _root.nodes[id].redrawWays();
269                                }
270                        }
271                        returnpath.push(_root.nodes[id]);
272                        done[id]=true;
273                }
274                return returnpath;
275        }
276
277
278        //              Created POI
279
280        UndoStack.prototype.undo_createpoi=function(params) {
281                poi=params[0]; poi.remove();
282                markClean(false);
283        };
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        };
290
291
292        // ---- renumberDeleted - give new ids to any nodes with only one way (i.e. deleted)
293
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.