├── .gitignore ├── AceJump.sublime-settings ├── AceJump.tmLanguage ├── Default (Linux).sublime-keymap ├── Default (OSX).sublime-keymap ├── Default (Windows).sublime-keymap ├── LICENSE ├── Main.sublime-menu ├── README.md └── ace_jump.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Sublime Text files 2 | ace-jump.sublime-project 3 | ace-jump.sublime-workspace 4 | 5 | # To do 6 | *.TODO 7 | -------------------------------------------------------------------------------- /AceJump.sublime-settings: -------------------------------------------------------------------------------- 1 | { 2 | // Characters to be used as labels in order they'll appear 3 | "labels": "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 4 | 5 | // Syntax highlighting scope for the labels 6 | "labels_scope": "invalid", 7 | 8 | // Toggles case sensitive search in word and character modes. 9 | "search_case_sensitivity": true, 10 | 11 | // Saves all the files aceJump tried to parse. 12 | // This setting will reset any linter warnings you might see during jump 13 | // By saving all effected files 14 | "save_files_after_jump": false, 15 | 16 | // If turned on, character mode will jump after a character 17 | // it it's the last character on a line. 18 | "jump_behind_last_characters": false, 19 | 20 | // View settings that should be respected when switching the syntax 21 | // highlighting mode. In case a plugin you use adds a new 22 | // setting to a view, you probably want to add it to this list. 23 | "view_settings": [ 24 | "auto_indent", 25 | "tab_size", 26 | "translate_tabs_to_spaces", 27 | "use_tab_stops", 28 | "trim_automatic_white_space", 29 | "detect_indentation", 30 | "draw_white_space", 31 | "trim_trailing_white_space_on_save", 32 | "always_show_minimap_viewport", 33 | "color_scheme", 34 | "font_face", 35 | "font_options", 36 | "gutter", 37 | "rulers", 38 | "draw_minimap_border", 39 | "highlight_line", 40 | "line_padding_top", 41 | "line_padding_bottom", 42 | "scroll_past_end", 43 | "line_numbers", 44 | "word_wrap", 45 | "wrap_width", 46 | "indent_subsequent_lines", 47 | "draw_centered", 48 | "match_brackets", 49 | "match_brackets_content", 50 | "match_brackets_square", 51 | "match_brackets_braces", 52 | "match_brackets_angle", 53 | ] 54 | } 55 | -------------------------------------------------------------------------------- /AceJump.tmLanguage: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | name 5 | AceJump 6 | hidden 7 | 8 | patterns 9 | 10 | 11 | match 12 | (.*) 13 | name 14 | text.ace_jump 15 | 16 | 17 | scopeName 18 | comment 19 | 20 | 21 | -------------------------------------------------------------------------------- /Default (Linux).sublime-keymap: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "keys": ["ctrl+shift+;"], 4 | "command": "ace_jump_word" 5 | }, 6 | { 7 | "keys": ["ctrl+shift+'"], 8 | "command": "ace_jump_char" 9 | }, 10 | { 11 | "keys": ["ctrl+shift+."], 12 | "command": "ace_jump_line" 13 | }, 14 | { 15 | "keys": ["ctrl+shift+,"], 16 | "command": "ace_jump_within_line" 17 | }, 18 | { 19 | "keys": ["alt+;"], 20 | "command": "ace_jump_select" 21 | }, 22 | { 23 | "keys": ["alt+'"], 24 | "command": "ace_jump_add_cursor" 25 | }, 26 | { 27 | "keys": ["alt+."], 28 | "command": "ace_jump_after" 29 | } 30 | ] 31 | -------------------------------------------------------------------------------- /Default (OSX).sublime-keymap: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "keys": ["super+shift+;"], 4 | "command": "ace_jump_word" 5 | }, 6 | { 7 | "keys": ["super+shift+'"], 8 | "command": "ace_jump_char" 9 | }, 10 | { 11 | "keys": ["super+shift+."], 12 | "command": "ace_jump_line" 13 | }, 14 | { 15 | "keys": ["super+shift+,"], 16 | "command": "ace_jump_within_line" 17 | }, 18 | { 19 | "keys": ["ctrl+;"], 20 | "command": "ace_jump_select" 21 | }, 22 | { 23 | "keys": ["ctrl+'"], 24 | "command": "ace_jump_add_cursor" 25 | }, 26 | { 27 | "keys": ["ctrl+."], 28 | "command": "ace_jump_after" 29 | } 30 | ] 31 | -------------------------------------------------------------------------------- /Default (Windows).sublime-keymap: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "keys": ["ctrl+shift+;"], 4 | "command": "ace_jump_word" 5 | }, 6 | { 7 | "keys": ["ctrl+shift+'"], 8 | "command": "ace_jump_char" 9 | }, 10 | { 11 | "keys": ["ctrl+shift+."], 12 | "command": "ace_jump_line" 13 | }, 14 | { 15 | "keys": ["ctrl+shift+,"], 16 | "command": "ace_jump_within_line" 17 | }, 18 | { 19 | "keys": ["alt+;"], 20 | "command": "ace_jump_select" 21 | }, 22 | { 23 | "keys": ["alt+'"], 24 | "command": "ace_jump_add_cursor" 25 | }, 26 | { 27 | "keys": ["alt+."], 28 | "command": "ace_jump_after" 29 | } 30 | ] 31 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Kuba Birecki 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /Main.sublime-menu: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "id": "preferences", 4 | "children": [ 5 | { 6 | "id": "package-settings", 7 | "children": [ 8 | { 9 | "caption": "AceJump", 10 | "children": [ 11 | { 12 | "caption": "README", 13 | "command": "open_file", 14 | "args": { 15 | "file": "${packages}/AceJump/README.md" 16 | } 17 | }, 18 | { 19 | "caption": "-" 20 | }, 21 | { 22 | "caption": "Settings - Default", 23 | "command": "open_file", 24 | "args": { 25 | "file": "${packages}/AceJump/AceJump.sublime-settings" 26 | } 27 | }, 28 | { 29 | "caption": "Settings - User", 30 | "command": "open_file", 31 | "args": { 32 | "file": "${packages}/User/AceJump.sublime-settings" 33 | } 34 | }, 35 | { 36 | "caption": "-" 37 | }, 38 | { 39 | "caption": "Key Bindings - Default", 40 | "command": "open_file", 41 | "args": { 42 | "file": "${packages}/AceJump/Default (OSX).sublime-keymap", 43 | "platform": "OSX" 44 | } 45 | }, 46 | { 47 | "caption": "Key Bindings - Default", 48 | "command": "open_file", 49 | "args": { 50 | "file": "${packages}/AceJump/Default (Linux).sublime-keymap", 51 | "platform": "Linux" 52 | } 53 | }, 54 | { 55 | "caption": "Key Bindings - Default", 56 | "command": "open_file", 57 | "args": { 58 | "file": "${packages}/AceJump/Default (Windows).sublime-keymap", 59 | "platform": "Windows" 60 | } 61 | }, 62 | { 63 | "caption": "Key Bindings - User", 64 | "command": "open_file", 65 | "args": { 66 | "file": "${packages}/User/Default (OSX).sublime-keymap", 67 | "platform": "OSX" 68 | } 69 | }, 70 | { 71 | "caption": "Key Bindings - User", 72 | "command": "open_file", 73 | "args": { 74 | "file": "${packages}/User/Default (Linux).sublime-keymap", 75 | "platform": "Linux" 76 | } 77 | }, 78 | { 79 | "caption": "Key Bindings - User", 80 | "command": "open_file", 81 | "args": { 82 | "file": "${packages}/User/Default (Windows).sublime-keymap", 83 | "platform": "Windows" 84 | } 85 | }, 86 | { 87 | "caption": "-" 88 | } 89 | ] 90 | } 91 | ] 92 | } 93 | ] 94 | } 95 | ] 96 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # AceJump 2 | 3 | A plugin for Sublime Text 3 heavily inspired by AceJump for emacs. 4 | 5 | AceJump allows you to move the cursor to any character to any place currently on screen. 6 | To clarify, you can jump between characters in all visible portions of currently open documents in any panes. 7 | Like it's emacs counterpart, AceJump for sublime features word (on the image below), character and line modes which make jumping even easier. 8 | 9 | ![AceJump](https://cloud.githubusercontent.com/assets/8056203/10858871/92069504-7f58-11e5-8593-e373121fd917.gif) 10 | 11 | After selecting a mode, you type in a character (except in line mode, where you don't have to type in anything) and appropriate labels are displayed. Then all you need to do is press the key from the label and voila! 12 | 13 | ## Installation 14 | 15 | ### PackageControl 16 | 17 | You can install AceJump from [PackageControl](http://wbond.net/sublime_packages/package_control) by following the steps below: 18 | 19 | - Open up the command palette and select ```Package Control: Install Package``` 20 | - Wait for the packages index to load and select ```AceJump``` 21 | 22 | ### Manual installation 23 | 24 | You can install AceJump manually using git by running the following command within sublime packages directory (Preferences > Browse Packages): 25 | 26 | ``` 27 | $ git clone git@github.com:ice9js/ace-jump-sublime.git AceJump/ 28 | ``` 29 | 30 | Or you can just copy the contents of this repository into ```Packages/AceJump```. 31 | 32 | ## Usage 33 | 34 | ### Word mode 35 | 36 | Goes to a word starting with the given character. This mode works only with alphanumeric characters. If you're interested in jumping to a special character, use character mode instead. 37 | 38 | - ```Ctrl/Super + Shift + ;``` 39 | - `````` 40 | - `````` 41 | 42 | No need to press enter after selecting a label! 43 | 44 | ![Word mode](https://cloud.githubusercontent.com/assets/8056203/10858875/921aa814-7f58-11e5-99ec-9d17fc22f313.gif) 45 | 46 | ### Character mode 47 | 48 | Goes to an occurence of the given character. 49 | 50 | - ```Ctrl/Super + Shift + '``` 51 | - `````` 52 | - `````` 53 | 54 | ![Character mode](https://cloud.githubusercontent.com/assets/8056203/10858870/92021b8c-7f58-11e5-916f-8ebc2d1d5eb4.gif) 55 | 56 | ### Line mode 57 | 58 | Labels all non-empty lines and lets you jump to one of them. 59 | 60 | - ```Ctrl/Super + Shift + .``` 61 | - `````` 62 | 63 | ![Line mode](https://cloud.githubusercontent.com/assets/8056203/10858872/9207c596-7f58-11e5-9353-2d57783ca2cc.gif) 64 | 65 | ### Within Line mode 66 | 67 | Labels all words within the line where current cursor locate and lets you jump to one of them. 68 | 69 | - ```Ctrl/Super + Shift + ,``` 70 | - `````` 71 | 72 | ### Select mode 73 | 74 | After triggering select mode, the next jump will select everything inbetween the current cursor position and the selected label. 75 | When select mode is triggered, the next jump is limited to the current file. 76 | 77 | - ```Alt+;``` (```Ctrl+;``` for OS X) 78 | - perform a jump using word, character or line mode 79 | 80 | ![Select mode](https://cloud.githubusercontent.com/assets/8056203/10858874/921207a4-7f58-11e5-936a-6e56ec80d486.gif) 81 | 82 | ### Multiple cursors mode 83 | 84 | After triggering multiple cursors mode, the next jump will add a new cursor to the view instead of moving the existing one. 85 | Again, when this mode is triggered, only jumps in the same file are available. 86 | 87 | - ```Alt+'``` (```Ctrl+'``` for OS X) 88 | 89 | ![Multiple cursors mode](https://cloud.githubusercontent.com/assets/8056203/10858873/9207ee86-7f58-11e5-9251-e74bd64dbfed.gif) 90 | 91 | ### Jump-after mode 92 | 93 | In this mode, the cursor will jump behind the targeted instance. Unfortunetely, 94 | this mode cannot be paired with select or multiple cursors mode yet. 95 | 96 | - ```Alt+.``` (```Ctrl+.``` for OS X) 97 | 98 | ![Jump-after mode](https://cloud.githubusercontent.com/assets/8056203/10858868/91fb4b22-7f58-11e5-8bdf-b489c6bb7ee2.gif) 99 | 100 | ### Batching 101 | 102 | In case there are more places to jump to than labels available, labels will be batched and you can cycle through them by simply pressing enter. 103 | 104 | ![Batching](https://cloud.githubusercontent.com/assets/8056203/10858869/92006792-7f58-11e5-9ece-6b94d1016147.gif) 105 | 106 | ## Customization 107 | 108 | In order to access AceJump settings, go to ```Preferences > Package Settings > AceJump > Settings - User```. 109 | 110 | ### Key bindings 111 | 112 | Go to ```Preferences > Package Settings > AceJump > Key Bindings - User```. 113 | You can then override the bindings for any of the following commands: 114 | 115 | - ```ace_jump_word``` 116 | - ```ace_jump_char``` 117 | - ```ace_jump_line``` 118 | - ```ace_jump_within_line``` 119 | - ```ace_jump_select``` 120 | - ```ace_jump_add_cursor``` 121 | - ```ace_jump_after``` 122 | 123 | The commands accept an optional Boolean `current_buffer_only` argument. When present and set to `true`, AceJump only performs on the currently edited buffer. 124 | 125 | ### Labels 126 | 127 | You can override the ```labels``` setting to provide your own set of labels to be used by AceJump. 128 | 129 | ### Highlighting 130 | 131 | You can also set the syntsx scope that's used for highlighting by overriding ```labels_scope```. The default scope is ```invalid```. 132 | 133 | ### Case sensitivity 134 | 135 | Ace jump is case sensitive by default. Case sensitivity can be toggled on and off by altering the ```search_case_sensitivity``` setting. 136 | 137 | ### Jumping behind the last character in a line 138 | 139 | By setting ```jump_behind_last_characters``` to ```true```, AceJump will jump behind a character if it's the last character on a line, without the need to trigger jump after mode. This only works in character mode and is switched off by default. 140 | 141 | ### Known issues 142 | 143 | It has been reported that the _Select mode_, _Multi cursors mode_ and _Jump after_ mode might not work using the specified keybinding. 144 | As a workaround for that follow these steps: 145 | 146 | - Start a regular search, e.g. word search (default keybinding: Ctrl+Shift+;). 147 | - **Before** entering any character, activate the advanced mode (e.g. for _Select mode_ use Alt+;). 148 | - Now enter the character to lookup. 149 | - Use the label to go to the corresponding location. 150 | -------------------------------------------------------------------------------- /ace_jump.py: -------------------------------------------------------------------------------- 1 | import sublime, sublime_plugin 2 | import re, itertools 3 | 4 | last_index = 0 5 | hints = [] 6 | search_regex = r'' 7 | 8 | next_search = False 9 | 10 | # MODES 11 | # 0: default (jumps in front of the selection) 12 | # 1: select 13 | # 2: add-cursor 14 | # 3: jump-after 15 | mode = 0 16 | 17 | ace_jump_active = False 18 | 19 | def get_active_views(window, current_buffer_only): 20 | """Returns all currently visible views""" 21 | 22 | views = [] 23 | if current_buffer_only: 24 | views.append(window.active_view()) 25 | else: 26 | for group in range(window.num_groups()): 27 | views.append(window.active_view_in_group(group)) 28 | return views 29 | 30 | def set_views_setting(views, setting, values): 31 | """Sets the values for the setting in all given views""" 32 | 33 | for i in range(len(views)): 34 | views[i].settings().set(setting, values[i]) 35 | 36 | def set_views_settings(views, settings, values): 37 | """Sets the values for all settings in all given views""" 38 | 39 | for i in range(len(settings)): 40 | set_views_setting(views, settings[i], values[i]) 41 | 42 | def get_views_setting(views, setting): 43 | """Returns the setting value for all given views""" 44 | 45 | settings = [] 46 | for view in views: 47 | settings.append(view.settings().get(setting)) 48 | return settings 49 | 50 | def get_views_settings(views, settings): 51 | """Gets the settings for every given view""" 52 | 53 | values = [] 54 | for setting in settings: 55 | values.append(get_views_setting(views, setting)) 56 | return values 57 | 58 | def set_views_syntax(views, syntax): 59 | """Sets the syntax highlighting for all given views""" 60 | 61 | for i in range(len(views)): 62 | views[i].set_syntax_file(syntax[i]) 63 | 64 | def set_views_sel(views, selections): 65 | """Sets the selections for all given views""" 66 | 67 | for i in range(len(views)): 68 | for sel in selections[i]: 69 | views[i].sel().add(sel) 70 | 71 | def get_views_sel(views): 72 | """Returns the current selection for each from the given views""" 73 | 74 | selections = [] 75 | for view in views: 76 | selections.append(view.sel()) 77 | return selections 78 | 79 | class AceJumpCommand(sublime_plugin.WindowCommand): 80 | """Base command class for AceJump plugin""" 81 | 82 | def run(self, current_buffer_only = False): 83 | global ace_jump_active 84 | ace_jump_active = True 85 | 86 | self.char = "" 87 | self.target = "" 88 | self.views = [] 89 | self.changed_views = [] 90 | self.breakpoints = [] 91 | 92 | self.all_views = get_active_views(self.window, current_buffer_only) 93 | self.syntax = get_views_setting(self.all_views, "syntax") 94 | self.sel = get_views_sel(self.all_views) 95 | 96 | settings = sublime.load_settings("AceJump.sublime-settings") 97 | self.highlight = settings.get("labels_scope", "invalid") 98 | self.labels = settings.get( 99 | "labels", 100 | "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" 101 | ) 102 | self.case_sensitivity = settings.get("search_case_sensitivity", True) 103 | self.jump_behind_last = settings.get("jump_behind_last_characters", False) 104 | self.save_files_after_jump = settings.get("save_files_after_jump", False) 105 | 106 | self.view_settings = settings.get("view_settings", []) 107 | self.view_values = get_views_settings( 108 | self.all_views, 109 | self.view_settings 110 | ) 111 | 112 | self.show_prompt(self.prompt(), self.init_value()) 113 | 114 | def is_enabled(self): 115 | global ace_jump_active 116 | return not ace_jump_active 117 | 118 | def show_prompt(self, title, value): 119 | """Shows a prompt with the given title and value in the window""" 120 | 121 | self.window.show_input_panel( 122 | title, value, 123 | self.next_batch, self.on_input, self.submit 124 | ) 125 | 126 | def next_batch(self, command): 127 | """Displays the next batch of labels after pressing return""" 128 | 129 | self.remove_labels() 130 | self.show_prompt(self.prompt(), self.char) 131 | 132 | def on_input(self, command): 133 | """Fires the necessary actions for the current input""" 134 | 135 | if len(command) == 1: 136 | self.char = command 137 | if self.char == "<" or self.char == ">": 138 | # re.escape escapes these 2 characters but it isn't needed for view.find() 139 | self.add_labels(self.regex().format(self.char)) 140 | else: 141 | self.add_labels(self.regex().format(re.escape(self.char))) 142 | return 143 | 144 | if len(command) == 2: 145 | self.target = command[1] 146 | 147 | self.window.run_command("hide_panel", {"cancel": True}) 148 | 149 | def submit(self): 150 | """Handles the behavior after closing the prompt""" 151 | global next_search, mode, ace_jump_active 152 | next_search = False 153 | 154 | self.remove_labels() 155 | set_views_sel(self.all_views, self.sel) 156 | set_views_syntax(self.all_views, self.syntax) 157 | 158 | if self.valid_target(self.target): 159 | self.jump(self.labels.find(self.target)) 160 | 161 | mode = 0 162 | ace_jump_active = False 163 | 164 | """Saves changed views after jump is complete""" 165 | if self.save_files_after_jump: 166 | for view in self.changed_views: 167 | if not view.is_read_only() and not view.is_dirty(): 168 | view.run_command("save") 169 | 170 | def add_labels(self, regex): 171 | """Adds labels to characters matching the regex""" 172 | 173 | global last_index, hints 174 | 175 | last_index = 0 176 | hints = [] 177 | 178 | self.views = self.views_to_label() 179 | self.region_type = self.get_region_type() 180 | self.changed_views = [] 181 | self.breakpoints = [] 182 | changed_buffers = [] 183 | 184 | for view in self.views[:]: 185 | if view.buffer_id() in changed_buffers: 186 | break 187 | 188 | view.run_command("add_ace_jump_labels", { 189 | "regex": regex, 190 | "region_type": self.region_type, 191 | "labels": self.labels, 192 | "highlight": self.highlight, 193 | "case_sensitive": self.case_sensitivity 194 | }) 195 | self.breakpoints.append(last_index) 196 | self.changed_views.append(view) 197 | changed_buffers.append(view.buffer_id()) 198 | 199 | if next_search: 200 | break 201 | 202 | self.views.remove(view) 203 | 204 | set_views_syntax(self.all_views, list(itertools.repeat( 205 | "Packages/AceJump/AceJump.tmLanguage", 206 | len(self.all_views) 207 | ))) 208 | 209 | set_views_settings( 210 | self.all_views, 211 | self.view_settings, 212 | self.view_values 213 | ) 214 | 215 | def remove_labels(self): 216 | """Removes all previously added labels""" 217 | 218 | last_breakpoint = 0 219 | for breakpoint in self.breakpoints: 220 | if breakpoint != last_breakpoint: 221 | view = self.changed_views[self.view_for_index(breakpoint - 1)] 222 | view.run_command("remove_ace_jump_labels") 223 | last_breakpoint = breakpoint 224 | 225 | def jump(self, index): 226 | """Performs the jump action""" 227 | 228 | region = hints[index].begin() 229 | view = self.changed_views[self.view_for_index(index)] 230 | 231 | self.window.focus_view(view) 232 | view.run_command("perform_ace_jump", {"target": region}) 233 | self.after_jump(view) 234 | 235 | def views_to_label(self): 236 | """Returns the views that still have to be labeled""" 237 | 238 | if mode != 0: 239 | return [self.window.active_view()] 240 | 241 | return self.all_views[:] if len(self.views) == 0 else self.views 242 | 243 | def view_for_index(self, index): 244 | """Returns a view index for the given label index""" 245 | 246 | for breakpoint in self.breakpoints: 247 | if index < breakpoint: 248 | return self.breakpoints.index(breakpoint) 249 | 250 | def valid_target(self, target): 251 | """Check if jump target is valid""" 252 | 253 | index = self.labels.find(target) 254 | 255 | return target != "" and index >= 0 and index < last_index; 256 | 257 | def get_region_type(self): 258 | """Return region type for labeling""" 259 | 260 | return "visible_region" 261 | 262 | class AceJumpWordCommand(AceJumpCommand): 263 | """Specialized command for word-mode""" 264 | 265 | def prompt(self): 266 | return "Head char" 267 | 268 | def init_value(self): 269 | return "" 270 | 271 | def regex(self): 272 | return r'\b{}' 273 | 274 | def after_jump(self, view): 275 | global mode 276 | 277 | if mode == 3: 278 | view.run_command("move", {"by": "word_ends", "forward": True}) 279 | mode = 0 280 | 281 | class AceJumpCharCommand(AceJumpCommand): 282 | """Specialized command for char-mode""" 283 | 284 | def prompt(self): 285 | return "Char" 286 | 287 | def init_value(self): 288 | return "" 289 | 290 | def regex(self): 291 | return r'{}' 292 | 293 | def after_jump(self, view): 294 | global mode 295 | 296 | if mode == 3: 297 | view.run_command("move", {"by": "characters", "forward": True}) 298 | mode = 0 299 | 300 | def jump(self, index): 301 | global mode 302 | 303 | view = self.changed_views[self.view_for_index(index)] 304 | if self.jump_behind_last and "\n" in view.substr(hints[index].end()): 305 | mode = 3 306 | 307 | return AceJumpCommand.jump(self, index) 308 | 309 | class AceJumpLineCommand(AceJumpCommand): 310 | """Specialized command for line-mode""" 311 | 312 | def prompt(self): 313 | return "" 314 | 315 | def init_value(self): 316 | return " " 317 | 318 | def regex(self): 319 | return r'(.*)[^\s](.*)\n' 320 | 321 | def after_jump(self, view): 322 | global mode 323 | 324 | if mode == 3: 325 | view.run_command("move", {"by": "lines", "forward": True}) 326 | view.run_command("move", {"by": "characters", "forward": False}) 327 | mode = 0 328 | 329 | class AceJumpWithinLineCommand(AceJumpCommand): 330 | """Specialized command for within-line-mode""" 331 | 332 | def prompt(self): 333 | return "" 334 | 335 | def init_value(self): 336 | return " " 337 | 338 | def regex(self): 339 | return r'\b\w' 340 | 341 | def after_jump(self, view): 342 | global mode 343 | 344 | if mode == 3: 345 | view.run_command("move", {"by": "word_ends", "forward": True}) 346 | mode = 0 347 | 348 | def get_region_type(self): 349 | 350 | return "current_line" 351 | 352 | class AceJumpSelectCommand(sublime_plugin.WindowCommand): 353 | """Command for turning on select mode""" 354 | 355 | def run(self): 356 | global mode 357 | 358 | mode = 0 if mode == 1 else 1 359 | 360 | class AceJumpAddCursorCommand(sublime_plugin.WindowCommand): 361 | """Command for turning on multiple cursor mode""" 362 | 363 | def run(self): 364 | global mode 365 | 366 | mode = 0 if mode == 2 else 2 367 | 368 | class AceJumpAfterCommand(sublime_plugin.WindowCommand): 369 | """Modifier-command which lets you jump behind a character, word or line""" 370 | 371 | def run(self): 372 | global mode 373 | 374 | mode = 0 if mode == 3 else 3 375 | 376 | class AddAceJumpLabelsCommand(sublime_plugin.TextCommand): 377 | """Command for adding labels to the views""" 378 | 379 | def run(self, edit, regex, region_type, labels, highlight, case_sensitive): 380 | global hints 381 | 382 | characters = self.find(regex, region_type, len(labels), case_sensitive) 383 | self.add_labels(edit, characters, labels) 384 | self.view.add_regions("ace_jump_hints", characters, highlight) 385 | 386 | hints = hints + characters 387 | 388 | def find(self, regex, region_type, max_labels, case_sensitive): 389 | """Returns a list with all occurences matching the regex""" 390 | 391 | global next_search, last_index 392 | 393 | chars = [] 394 | 395 | region = self.get_target_region(region_type) 396 | next_search = next_search if next_search else region.begin() 397 | last_search = region.end() 398 | 399 | while (next_search < last_search and last_index < max_labels): 400 | word = self.view.find(regex, next_search, 0 if case_sensitive else sublime.IGNORECASE) 401 | 402 | if not word or word.end() > last_search: 403 | break 404 | 405 | last_index += 1 406 | next_search = word.end() 407 | chars.append(sublime.Region(word.begin(), word.begin() + 1)) 408 | 409 | if last_index < max_labels: 410 | next_search = False 411 | 412 | return chars 413 | 414 | def add_labels(self, edit, regions, labels): 415 | """Replaces the given regions with labels""" 416 | 417 | for i in range(len(regions)): 418 | self.view.replace( 419 | edit, regions[i], labels[last_index + i - len(regions)] 420 | ) 421 | 422 | def get_target_region(self, region_type): 423 | 424 | return { 425 | 'visible_region': lambda view : view.visible_region(), 426 | 'current_line': lambda view : view.line(view.sel()[0]), 427 | }.get(region_type)(self.view) 428 | 429 | class RemoveAceJumpLabelsCommand(sublime_plugin.TextCommand): 430 | """Command for removing labels from the views""" 431 | 432 | def run(self, edit): 433 | self.view.erase_regions("ace_jump_hints") 434 | self.view.end_edit(edit) 435 | self.view.run_command("undo") 436 | 437 | class PerformAceJumpCommand(sublime_plugin.TextCommand): 438 | """Command performing the jump""" 439 | 440 | def run(self, edit, target): 441 | global mode 442 | if mode == 0 or mode == 3: 443 | self.view.sel().clear() 444 | 445 | self.view.sel().add(self.target_region(target)) 446 | self.view.show(target) 447 | 448 | def target_region(self, target): 449 | if mode == 1: 450 | for cursor in self.view.sel(): 451 | return sublime.Region(cursor.begin(), target) 452 | 453 | return sublime.Region(target) 454 | --------------------------------------------------------------------------------