Example (indentation guides shown for illustration purposes):

1: foo() {
2: |    if (bar) {
3: |    |    for (condition) {
4: |    |    |    baz();
5: |    |    }
6: |    }
7: }

If the cursor is on line 2, the second indentation guide should be highlighted, because line 2 starts at that indentation level. This will result in very easy visual identification of the matching closing brace, regardless of the cursor position within the actual line.

When running the "subl" command on the same path it always opens a new windows containing the file rather than using the existing project already pointing to that path. It works correctly for files. For example

running "subl ." and then "subl views/somefile.html" will use the same window that "subl ." opened up.

However running "subl ." a second time will open a new window even though that project is already open. Probably a small thing, but I have run into it a few times while just evaluating sublime. I am switching from bbedit which does do this correctly.

Currently, quoted literals are treated somewhat incorrectly in regard to auto-completion. E.g. in php:

mysql_query('SELECT id FROM test WHERE id IN()');

Typing `'` within the `IN()` brackets behaves as expected. The literal string is also highlighted. However, if one has the exact same literal, spanning across several lines, things stop working:

        mysql_query('

            SELECT id 

            FROM test 

            WHERE id IN()

        ');

Highlighting no longer works. Typing `'` withing `IN()` brackets does not insert matching `'`. If one types in the second `'` manually, it is auto-completed this time around, resulting in `IN(' '')`.

Basically, this results in editing larger strings extremely inconvenient. The example query is short, but imagine it having 5 joins -- it would get extremely large, and editing it as a one-liner would be a pain.

Same goes for C multiline literals.

A better way to handle the key conflicts is to popup a list of all commands mapped to the same shortcut and let the user choose which command they want to execute (instead of ST executing one by default and ignoring the rest). Often times new packages introduce key conflicts and it's rather inconvenient for the user to have to re-map the conflicting shortkeys. It's likely that multiple operations sharing a shortkey are all useful thus necessary to be kept by resolving the key conflicts, which requires a careful remapping of these operations in order to avoid introducing further conflicts with yet other operations. IMO the key conflict resolution task should be handled by ST instead of being left up to the user.

I would like to be able to define in settings when to filter out browser files which match a source / compiled file pattern: for example, I don't want to hide all .js files from my project, but if in same directory there is a foo.coffee file, I would like to hide foo.js because it can be expected to be compiled from the other file.

Of course I can define per project 'hide .js files in folder x', but it would be easier to be able to configure 'whenever I have .coffee hide matching .js'.

If I have date.js in a directory without matching 'js source' files in same directory, the date.js should be shown: this is why current file_exclude_patterns does not work in this case.

Example how this might be configured in user settings (globally, not per project):

compiled_file_extension_exclude_patters = {

'.js': [ '.coffee' ],

'css': [ '.less', '.coffee' ]

This is very comfortable for ordering tabs.

Currently, each window can have multiple panes depending on your layout settings. However, when you work on e.g. a large client- and server-side javascript project, you can easily have many related files open in tabs in each pane that you need to switch between fairly often. Goto Anything is ok, but it's not as fast or as easy to work in as if some of the files were rendered into one composite file. I think this is because it is easier for me to remember which code point I need to find and use the Find feature than to remember which file it is in and use Goto Anything, unless I'm misunderstanding how to use Goto Anything. Sometimes it's even faster to just use the mouse to pick the right tab than to try with ctrl+tab (I would prefer tab-order to time-order or whatever the current ordering is) or type the file name in Goto Anything.

So, what I'd really want is something that takes a bunch of separate files and presents them as one file, with collapsible/reorderable boundaries between files. This happens to have a side effect of making it easy to have one file with multiple different syntax highlighting and other language-specific features. I imagine it could be implemented as something like a pre-processor where I specify a config file with all the different groupings (and maybe also stuff like strings to prepend and append to each file). Ideally I could also take the same config file and output the composited files to the file system like make or other build process tools.

Other than that, I love Sublime. Keep up the great work!

What we do:

• We are the number one provider of college, school and Early Years inspections in the UK, on behalf of Ofsted.

• Through i-graduate, we provide evidence-based information on education experience and outcomes across the Higher Education, Further Education and schools markets, working with over 1200 education institutions in 24 countries.

• We are the number two provider of Children’s Management systems to Local Government in the UK.

• We are implementing technology to support one of the world’s largest educational change programmes in New South Wales, Australia.

• http://www.wattpad.com/37599431-how-to-apply-to-tribal-group-westhill-consulting
• http://www.wallstreetoasis.com/blog/cs-healthcare-westhill-consulting-guide-to-consultants