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

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

Potlatch 1.1a

File size: 8.3 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
22                _root.undoing=true;                                     //  | undo stack
23                if (this.sp==0) { return; }
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("Nothing to undo",'tip_noundo')); };
35                        _root.panel.i_undo._alpha=50;
36                } else {
37                        _root.panel.i_undo.onRollOver=function() { setFloater(iText("Undo $1 (Z)",'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("Way $1 cannot be found (perhaps you've panned away?) so I can't undo.",'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("Ways $1 and $2 don't share a common point any more, so I can't undo the split.",'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("Way $1 cannot be found (perhaps you've panned away?) so I can't undo.",'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("Way $1 cannot be found (perhaps you've panned away?) so I can't undo.",'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("The POI cannot be found (perhaps you've panned away?) so I can't undo.",'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("The POI cannot be found (perhaps you've panned away?) so I can't undo.",'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("Way $1 cannot be found (perhaps you've panned away?) so I can't undo.",'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("Way $1 cannot be found (perhaps you've panned away?) so I can't undo.",'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 oldway=params[0]; newwayid--;
215                stopDrawing();
216                _root.map.ways.attachMovie("way",newwayid,++waydepth);
217                _root.map.ways[newwayid]._x=params[1];
218                _root.map.ways[newwayid]._y=params[2];
219                _root.map.ways[newwayid].attr=params[3];
220                _root.map.ways[newwayid].path=renumberDeleted(params[4],oldway,newwayid);
221                _root.map.ways[newwayid].version=params[5];
222                _root.map.ways[newwayid].redraw();
223                _root.map.ways[newwayid].select();
224                _root.map.ways[newwayid].clean=false;
225                markClean(false);
226        };
227
228        //              Changed path (for tidying)
229
230        UndoStack.prototype.undo_changeway=function(params) {
231                var way=params[0]; var w=_root.map.ways[way];
232                var path=params[1]; var done=new Object();
233                // we need to be careful not to end up with duplicate versions of
234                // the same node
235                w.path=new Array();
236                for (var i=0; i<path.length; i++) {
237                        var id=path[i].id;
238                        if (!done[id]) {
239                                if (_root.nodes[id]) {
240                                        _root.nodes[id].x=path[i].x;
241                                        _root.nodes[id].y=path[i].y;
242                                        _root.nodes[id].attr=path[i].attr;
243                                        _root.nodes[id].tagged=hasTags(path[i].attr);
244                                        _root.nodes[id].version=path[i].version;
245                                        _root.nodes[id].clean=false;
246                                        _root.nodes[id].addWay(way);
247                                } else {
248                                        _root.nodes[id]=deepCopy(path[i]);
249                                }
250                                if (_root.nodes[id].numberOfWays()>1) {
251                                        _root.nodes[id].redrawWays();
252                                }
253                        }
254                        w.path.push(_root.nodes[id]);
255                        done[id]=true;
256                }
257                w.deletednodes=params[2];
258                w.attr=params[3];
259                stopDrawing();
260                w.redraw();
261                w.select();
262                w.clean=false;
263                markClean(false);
264        };
265
266        //              Created POI
267
268        UndoStack.prototype.undo_createpoi=function(params) {
269                poi=params[0]; poi.remove();
270                markClean(false);
271        };
272       
273        //              Created ways (e.g. parallel)
274       
275        UndoStack.prototype.undo_makeways=function(params) {
276                for (i in params) { _root.map.ways[params[i]].remove(); }
277        };
278
279
280        // ---- renumberDeleted - give new ids to any nodes with only one way (i.e. deleted)
281
282        function renumberDeleted(path,oldway,newway) {
283                for (var i in path) {
284                        if (path[i].numberOfWays()==1 && path[i].ways[oldway]) {
285                                newnodeid--;
286                                path[i].id=newnodeid;
287                                path[i].version=0; path[i].clean=false;
288                                path[i].ways=new Object(); path[i].ways[newway]=true;
289                                _root.nodes[newnodeid]=path[i]; // path[i].renumberTo(newnodeid);
290                        } else {
291                                var z=path[i].ways; delete z[oldway]; z[newway]=true;
292                                _root.nodes[path[i].id]=path[i];
293                        }
294                }
295                return path;
296        }
Note: See TracBrowser for help on using the repository browser.