I have a feature suggestion. I've thought about this for years but it has only just occurred to me to say something about it.
As you know, I use TextMate to write books. Big books with big chapters. So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before.
That's the suggestion. TextMate should _automatically_ maintain "bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before.
Just an idea. (A really great idea!) m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
Seconded! A long time ago I used an editor that had this feature (Edison on Atari ST/TT), that was tremendously useful.
I think I requested that feature several times over the years. If TM wouldn't be written mostly in C++ (gag) I long since would have added this and a whole slew of features.
Gerd
On Sep 22, 2014, at 9:09 AM, Matt Neuburg matt@tidbits.com wrote:
I have a feature suggestion. I've thought about this for years but it has only just occurred to me to say something about it.
As you know, I use TextMate to write books. Big books with big chapters. So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before.
That's the suggestion. TextMate should _automatically_ maintain "bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before.
Just an idea. (A really great idea!) m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
+1 from here too
I resort for the poor man's version (⌘Z / ⌘⇧Z) all the time, but works only if there had been an edit of course
Elia
📢 twitter/elia http://twitter.com/elia ☕️ github/elia http://github.com/elia
On Mon, Sep 22, 2014 at 6:04 PM, Gerd Knops gerti-textmate@bitart.com wrote:
Seconded! A long time ago I used an editor that had this feature (Edison on Atari ST/TT), that was tremendously useful.
I think I requested that feature several times over the years. If TM wouldn't be written mostly in C++ (gag) I long since would have added this and a whole slew of features.
Gerd
On Sep 22, 2014, at 9:09 AM, Matt Neuburg matt@tidbits.com wrote:
I have a feature suggestion. I've thought about this for years but it
has only just occurred to me to say something about it.
As you know, I use TextMate to write books. Big books with big chapters.
So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before.
That's the suggestion. TextMate should _automatically_ maintain
"bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before.
Just an idea. (A really great idea!) m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
I think the feature requested here is a bit fuzzy.
Matt wants to do multiple edits in location A, then go to location B, do multiple edits, and have a way to get back to location A. Did I get that right? There is a current bookmark implementation, but you need to set them explicitly with ⌘F2 and can jump to next/previous with F2/⇧F2.
Elia wants to “scroll back” and says (about the poor man’s version) “works only if there had been an edit”, so it seems where to scroll back to is “where I was last, regardless of wether or not I did any edits”. So the definition of where to scroll back to is unclear to me.
My interpretation of Gerd’s request (from earlier) is that each time the caret moves more than a line (after an edit), the position is added to the stack. But I am not sure if this would be a satisfying heuristic. There should probably be some collapsing of locations based on distance/within the view port.
Gerd: If you do have a clear definition of how it should work, please let me know.
On 22 Sep 2014, at 18:07, Elia Schito wrote:
+1 from here too
I resort for the poor man's version (⌘Z / ⌘⇧Z) all the time, but works only if there had been an edit of course
Elia
📢 twitter/elia http://twitter.com/elia ☕️ github/elia http://github.com/elia
On Mon, Sep 22, 2014 at 6:04 PM, Gerd Knops gerti-textmate@bitart.com wrote:
Seconded! A long time ago I used an editor that had this feature (Edison on Atari ST/TT), that was tremendously useful.
I think I requested that feature several times over the years. If TM wouldn't be written mostly in C++ (gag) I long since would have added this and a whole slew of features.
Gerd
On Sep 22, 2014, at 9:09 AM, Matt Neuburg matt@tidbits.com wrote:
I have a feature suggestion. I've thought about this for years but it
has only just occurred to me to say something about it.
As you know, I use TextMate to write books. Big books with big chapters.
So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before.
That's the suggestion. TextMate should _automatically_ maintain
"bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before.
Just an idea. (A really great idea!) m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
On Sep 22, 2014, at 9:41 AM, Allan Odgaard mailinglist@textmate.org wrote:
There is a current bookmark implementation, but you need to set them explicitly with ⌘F2
Right, of course. This is what I'm asking not to have to do. That's my point. Just _make_ me a bookmark wherever I am editing. Don't make this list too long; 2 levels would do (i.e. always keep autobookmarks at the 2 most recent places I edited).
Example: on my GPS when I go running, there is an automatic waypoint set at my starting point, so if my run involves looping back, I can navigate to my starting place.
Another example: In iBooks, if you tap a footnote marker to read the note, or use the chapter window to navigate to a different chapter, a "Back to p. xxx" button appears at the lower left.
These are examples of how things in my world let me go elsewhere for a while and then return to where I was, automatically.
TextMate should do that.
m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
On Sep 22, 2014, at 11:41 AM, Allan Odgaard mailinglist@textmate.org wrote:
I think the feature requested here is a bit fuzzy.
[..]
My interpretation of Gerd’s request (from earlier) is that each time the caret moves more than a line (after an edit), the position is added to the stack. But I am not sure if this would be a satisfying heuristic. There should probably be some collapsing of locations based on distance/within the view port.
Gerd: If you do have a clear definition of how it should work, please let me know.
Certainly a fuzzy feature... Back then on small screens it was basically "moved more than a line". Now with large windows, it is trickier to find a good metric. Distance in the view port seems to factor in.
Maybe this would work: still record every change in position that is more than a line, but then when going backward/forward in the history discard positions that are currently visible. Of course this may be too much, so it might need to be more like "visible and not more than y lines away from current cursor position".
And I do think the "jump buffer" should span all files, not be limited to the one currently viewed. So say I work in file x, now go to look at something in file y (or even edit there) and "jump back", it should jump back to file x (even if I closed it!).
And to add extra bells and whistles, there'd be an (optional) visual navigator that shows previous edit locations with context!
Gerd
On 22 Sep 2014, at 18:07, Elia Schito wrote:
+1 from here too
I resort for the poor man's version (⌘Z / ⌘⇧Z) all the time, but works only if there had been an edit of course
Elia
📢 twitter/elia <http://twitter.com/elia http://twitter.com/elia> ☕️ github/elia <http://github.com/elia http://github.com/elia>
On Mon, Sep 22, 2014 at 6:04 PM, Gerd Knops <gerti-textmate@bitart.com mailto:gerti-textmate@bitart.com> wrote:
Seconded! A long time ago I used an editor that had this feature (Edison on Atari ST/TT), that was tremendously useful.
I think I requested that feature several times over the years. If TM wouldn't be written mostly in C++ (gag) I long since would have added this and a whole slew of features.
Gerd
On Sep 22, 2014, at 9:09 AM, Matt Neuburg <matt@tidbits.com mailto:matt@tidbits.com> wrote:
I have a feature suggestion. I've thought about this for years but it
has only just occurred to me to say something about it.
As you know, I use TextMate to write books. Big books with big chapters.
So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before.
That's the suggestion. TextMate should _automatically_ maintain
"bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before.
Just an idea. (A really great idea!) m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
textmate mailing list textmate@lists.macromates.com mailto:textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate http://lists.macromates.com/listinfo/textmate
That is a GREAT idea, one which I sure we have all experienced at a latent level (“God I wish I could just go back to there now…”)
tricky to implement where “there” is, but yes: let’s figure it out
My current solution is Allan’s lovely new (ish?) show all finds.
But it’s an effort. What we need is something as intuitive as cntrl-W has turned out to be: you just “go back to the last place you were editing stuff” with a simple “return” keystroke… ^⌥⌘-G?
t
— Sent from Mailbox
On Mon, Sep 22, 2014 at 3:09 PM, Matt Neuburg matt@tidbits.com wrote:
I have a feature suggestion. I've thought about this for years but it has only just occurred to me to say something about it. As you know, I use TextMate to write books. Big books with big chapters. So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before. That's the suggestion. TextMate should _automatically_ maintain "bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before. Just an idea. (A really great idea!) m. -- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html _______________________________________________ textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
I developed a bundle I called "Navigator" for TM 1.5 that does that. Actually it does a lot more. Among others it implements a position stack with push/pop position, navigation within the stack, and coupled with its symbol tagging system it allows for an automatic call/return type of navigation to the symbol under the caret. If required it will open documents as needed. It also implements the function of project and global named bookmarks and navigation.
I haven't had the time to update it to 2.0 but I should be working on it soon. Another problem to migrate it to TM 2.0 is that TMTOOLS is not supported anymore and I used it for precise positioning when documents have changed since the position was saved.
Anyway, of you are patient I believe it could help you.
On 22 sept. 2014, at 16:09, Matt Neuburg matt@tidbits.com wrote:
I have a feature suggestion. I've thought about this for years but it has only just occurred to me to say something about it.
As you know, I use TextMate to write books. Big books with big chapters. So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before.
That's the suggestion. TextMate should _automatically_ maintain "bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before.
Just an idea. (A really great idea!) m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
On 22 Sep 2014, at 18:30, Eduardo Francos wrote:
I developed a bundle I called "Navigator" for TM 1.5 that does that. Actually it does a lot more. Among others it implements a position stack with push/pop position, navigation within the stack
Sounds like this could be tackled by extended the current bookmark system with a “go back to last bookmark added and remove it (and make it work accross files)”-action, and we would have this push/pop system.
[…] TMTOOLS is not supported anymore and I used it for precise positioning when documents have changed since the position was saved.
Curious, how was TMTOOLS able to help with that?
My bad for shifting the target, sorry. I'll try to observe myself better and send a separate request that fits my usage (and possibly other's).
Elia
📢 twitter/elia http://twitter.com/elia ☕️ github/elia http://github.com/elia
On Mon, Sep 22, 2014 at 6:50 PM, Allan Odgaard mailinglist@textmate.org wrote:
On 22 Sep 2014, at 18:30, Eduardo Francos wrote:
I developed a bundle I called "Navigator" for TM 1.5 that does that.
Actually it does a lot more. Among others it implements a position stack with push/pop position, navigation within the stack
Sounds like this could be tackled by extended the current bookmark system with a “go back to last bookmark added and remove it (and make it work accross files)”-action, and we would have this push/pop system.
[…] TMTOOLS is not supported anymore and I used it for precise
positioning when documents have changed since the position was saved.
Curious, how was TMTOOLS able to help with that?
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
On 22 sept. 2014, at 18:50, Allan Odgaard mailinglist@textmate.org wrote:
On 22 Sep 2014, at 18:30, Eduardo Francos wrote:
I developed a bundle I called "Navigator" for TM 1.5 that does that. Actually it does a lot more. Among others it implements a position stack with push/pop position, navigation within the stack
Sounds like this could be tackled by extended the current bookmark system with a “go back to last bookmark added and remove it (and make it work accross files)”-action, and we would have this push/pop system.
I agree. As long as you have a push/pop type of mechanism you have the functionality. However, current bookmarks are document based so if the document has been closed then the pop cannot work as is. Positioning bookmarks need to be kept available all the time. I use a file to keep the stack information between bundle calls. I guess this information could be managed more efficiently inside TM. The "push" could be done automatically to save the extra keystroke but as mentioned by others it's not easy to determine when a push must be done. For what it's worth, when I tried to implement automatic pushes I decided on two relatively simplistic conditions: 1) Whenever you edit a line its position is pushed. Previous pushed positions are poped and discarded while they are located within a number of lines of the current one. This in order to avoid the pain of going back to each one of them separately. 2) Whenever the caret stays on the same line or group of lines for longer than a given number of seconds the position is pushed. I translate this as "the position is interesting".
[…] TMTOOLS is not supported anymore and I used it for precise positioning when documents have changed since the position was saved.
Curious, how was TMTOOLS able to help with that?
It's related to the issue of files being modified after the position has been pushed so the stored position is not exactly right. After determining the file and position to jump to, and telling TM (via mate) to open the file at the position, I then use TMTOOLS to call a bundle command that would check that the line is still there. If it's not then search a (configurable) number of lines up and down to try to find it. This gives me precise positioning almost always. In a more general way I use TMTOOLS to be able to call back into TM and continue a logic that is dependent on TM doing something in between. It would be nice if the command line "mate" could do that type of things... but that's a different story :p
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
I'd find this feature useful, even for coding. Personally I wouldn't want it to span files, or if it did, have the ability to disable that.
I also wouldn't want it to re-purpose the existing bookmarks system, which I already use for navigating.
But there's a lot of talk about how to detect line changes, and when to push a position onto the stack. It seems to me the easiest way would be just to backscan through the undo buffer, which can already tell us which lines have been changed on what line.
Personally I would just keep it really simple, and have a key combo which backtraces through the undo buffer jumping to lines which were changed (without undoing anything obviously).
As soon as you start adding timers, or refusing to jump to lines which are already visible, these things tend to just become unpredictable for the user, and end up being an annoyance rather than something useful.
On 22 September 2014 21:05, Eduardo Francos efrancos@efrancos.com wrote:
On 22 sept. 2014, at 18:50, Allan Odgaard mailinglist@textmate.org wrote:
On 22 Sep 2014, at 18:30, Eduardo Francos wrote:
I developed a bundle I called "Navigator" for TM 1.5 that does that. Actually it does a lot more. Among others it implements a position
stack with push/pop position, navigation within the stack
Sounds like this could be tackled by extended the current bookmark
system with a “go back to last bookmark added and remove it (and make it work accross files)”-action, and we would have this push/pop system.
I agree. As long as you have a push/pop type of mechanism you have the functionality. However, current bookmarks are document based so if the document has been closed then the pop cannot work as is. Positioning bookmarks need to be kept available all the time. I use a file to keep the stack information between bundle calls. I guess this information could be managed more efficiently inside TM. The "push" could be done automatically to save the extra keystroke but as mentioned by others it's not easy to determine when a push must be done. For what it's worth, when I tried to implement automatic pushes I decided on two relatively simplistic conditions:
- Whenever you edit a line its position is pushed. Previous pushed
positions are poped and discarded while they are located within a number of lines of the current one. This in order to avoid the pain of going back to each one of them separately. 2) Whenever the caret stays on the same line or group of lines for longer than a given number of seconds the position is pushed. I translate this as "the position is interesting".
[…] TMTOOLS is not supported anymore and I used it for precise
positioning when documents have changed since the position was saved.
Curious, how was TMTOOLS able to help with that?
It's related to the issue of files being modified after the position has been pushed so the stored position is not exactly right. After determining the file and position to jump to, and telling TM (via mate) to open the file at the position, I then use TMTOOLS to call a bundle command that would check that the line is still there. If it's not then search a (configurable) number of lines up and down to try to find it. This gives me precise positioning almost always. In a more general way I use TMTOOLS to be able to call back into TM and continue a logic that is dependent on TM doing something in between. It would be nice if the command line "mate" could do that type of things... but that's a different story :p
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
On Sep 22, 2014, at 1:42 PM, Carpii UK carpii.uk@gmail.com wrote:
I also wouldn't want it to re-purpose the existing bookmarks system, which I already use for navigating.
I only suggested that because I thought it would make it easier (leverage existing interface / tech). m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
I want this feature ALL THE TIME. There was some editor I used in the distant past that had this and it was super convenient. For me going between files would be helpful, not only within one file. Kind of like the back/forward buttons in a web browser.
I appreciate it's probably complex to figure out how to do it, and satisfying everyone's particular flavor is impossible.
Sorry I don't have time to give a more concrete suggestion at the moment. --ErikN
On Mon, Sep 22, 2014 at 7:09 AM, Matt Neuburg matt@tidbits.com wrote:
I have a feature suggestion. I've thought about this for years but it has only just occurred to me to say something about it.
As you know, I use TextMate to write books. Big books with big chapters. So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before.
That's the suggestion. TextMate should _automatically_ maintain "bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before.
Just an idea. (A really great idea!) m.
-- matt neuburg, phd = http://www.apeth.net/matt/ pantes anthropoi tou eidenai oregontai phusei Programming iOS 7! http://shop.oreilly.com/product/0636920031017.do iOS 7 Fundamentals! http://shop.oreilly.com/product/0636920032465.do RubyFrontier! http://www.apeth.com/RubyFrontierDocs/default.html
textmate mailing list textmate@lists.macromates.com http://lists.macromates.com/listinfo/textmate
Hi,
I ONLY would like to think loudly and !!quickly!!, thus please forgive me if I miss something essential
If we’re talking “only” about to jump to the last caret position (I’d argue to listen to a selection change rather than to an actual edit, because it often occurs that one goes to somewhere else to copy a chunk of text or read something only, ergo no actual edit happens) then this could be at least a possible starting point:
Each document should store two records [last_MARKER, current_MARKER] to hold these 3 variables: - file_path (of the current doc) - current_selected_range [curRange] - range_of_visible_line_numbers [visibleRange] (first visible line number in view port (window) and length to the last visible line number)
I define the circumstance whether a caret position has to be stored in a global stack (of size 2) or not via the first visible line number and the last visible line number of the current window plus the actual line number of the caret. In other words, each caret position (line number) which is not inside of the last remembered marker's first and last visible line numbers should be a candidate for the global stack. For a selection, do set [last_MARKER] only if both line numbers (begin and end of the selection) are inside of the last remembered marker’s visibleRange.
Pseudo-Code:
+ init [last_MARKER] with defaults {for each doc}
* listen to selectionDidChange notification + get line number of the begin of the current selection [curBegLineNr] + get line number of the end of the current selection [curEndLineNr] + set [current_MARKER] to current values if [curBegLineNr] inRange [last_MARKER.visibleRange] then // save the current status only if // the line number of the end of a possible selection // is also within the last range of visible line numbers // to avoid storing if user “only” selected a // a large chunk - a next notification should handle this // or // if a doc change just happened if ([curEndLineNr] inRange [last_MARKER.visibleRange]) or (STACK.size > 0 AND STACK[0].file_path <> current_MARKER.file_path) then set [last_MARKER] to [current_MARKER] endif else // caret is outside of the last visible view port, // ergo add MARKER to global STACK set [last_MARKER] to [current_MARKER] move STACK[0] to STACK[1] and insert [last_MARKER] to STACK[0] endif
* listen to active document will be changed + move STACK[0] to STACK[1] and insert [last_MARKER] of the not yet inactive doc to STACK[0]
= navigation - Jump to last caret position A “Jump to last caret position” command should take the last inserted MARKER.file_path and MARKER.curRange to restore that doc plus caret position AND swap both entries in the STACK in order to be able to jump to and fro between the both last positions.
Remark: A stack size of 2 would have the advantage that one hasn’t to care about deletions, validations of ranges, etc. within docs, otherwise each update of the stack should check if all MARKERs are still valid.
Cheers, Hans
Am 2014-09-23 um 01:19 schrieb Erik Neumann:
I want this feature ALL THE TIME. There was some editor I used in the distant past that had this and it was super convenient. For me going between files would be helpful, not only within one file. Kind of like the back/forward buttons in a web browser.
*+1*
Has this been tackled in the meantime?
On Mon, Sep 22, 2014 at 7:09 AM, Matt Neuburg matt@tidbits.com wrote:
I have a feature suggestion. I've thought about this for years but it has only just occurred to me to say something about it.
As you know, I use TextMate to write books. Big books with big chapters. So it often happens that I edit a chapter, then jump to an earlier / later bit of that same chapter to make some change entailed by what I was just writing. Now I want to "go back" to where I was before.
That's the suggestion. TextMate should _automatically_ maintain "bookmarks" for the location of the two most recent edit locations (places where I actually typed or deleted text). Thus, I could use the bookmarks feature to jump back to where I was before.
… mit freundlichem Gruß aus Ladenburg:
-Moss-
-
Allan Odgaard -
Carpii UK -
Eduardo Francos -
Elia Schito -
Erik Neumann -
Gerd Knops -
Hans-Jörg Bibiko -
Martin Wilhelm Leidig -
Matt Neuburg -
Timothy Bates