Add Caret mode

Fixes #480.

Improve "open link in new tab" interoperability

When opening a link in a new tab, such as when using the `F` or `gf` commands,
we now try to closely mimic what Firefox does when you click links using the
mouse, instead of directly using `gBrowser.loadOneTab(url, options)`.

This provides interoperability with the BackTrack Tab History add-on, which
fixes #720, and allows to remove Tree Style Tab-specific code.

Move viewport calculations from hints.coffee to utils.coffee

It's cleaner and more reusable.

This also fixes a slight bug for markers in frames. Previously, if the frame had
padding and/or borders its calculated viewport was a tiny bit too large. Now,
padding and borders are taken into account.

Change `<c-a>` to `<c-enter>` in Hints mode

Using `<c-a>` for marking _all_ elements was nice, because `<c-a>` usually means
"select all". However, it conflicts with the "hold ctrl when typing the last
hint character to toggle if the link opens in a new tab or not" feature. If the
last character was an "a" that wouldn't happen; instead, the `<c-a>` command
would be invoked. This commit changes to `<c-enter>` which should be conflict
free.

Add the `<c-a>` Hints mode command to mark everything

Fix argument order of an `isInsideViewport` call

Remove horizontal alignment in multiline function calls

This is to reduce unnecessary diffs and to be able to use search-and-replace to
rename things without having to worry about fixing alignment.

Fix `__dirname` in config files on Windows

`OS.Path.dirname` does not seem to support `file://` URIs on Windows.
`OS.Path.dirname('file:///C:/Users/foo/.vimfx/config.js')` returns `'file:'`.

This commit calculates the dirname in a different way to work around the above
problem.

Thanks to @azuwis for finding out and suggesting a fix.

Supersedes and closes #719.

Remove unnecessary full-page hint marker on Hackernews

VimFx v0.13.2

Fix illogical code order in scrolling commands

Logically, one should set the `last_position_mark` mark _before_ jumping
somwhere. However, for the `G`, `g`, `$` and `0` commands, the message to set it
was sent _after_ the message to scroll was sent!

Somehow it has still worked as intended for me.

This commit reverses the order.

This might fix #717.

Allow `<space>` to toggle play/pause in more video players

Fix wrong viewport size for hints in quirks mode

Update devDependencies

Fix lint error

Remove unnecessary `return` in commands.coffee

VimFx v0.13.1

Improve automatic mode switching on page load

Previously, Normal mode was _always_ entered on location change (page load)
(unless the page is blacklisted; then Ignore mode is entered instead). There
were to reasons for this: Handling the blacklist, and auto-exiting hints mode
(because hints left over from another page does not make sense in a new page).
However, this caused a few problems:

- If you used the `zF` command while a page was loading, the markers would
  disappear when the page fired the "location change" event.
- There was an ugly special case for Find mode, making sure not to enter Normal
  mode if currently in Find mode (see commit fc7e61e7c).
- Sometimes, you can enter Hints mode on a newly loaded page just before the
  page fires the "location change" event, making hints annoyingly disappear.

This commit changes two things:

- Hints mode is automatically exited (by returning to Normal mode) on the
  'pagehide' event instead.
- The current mode is only changed on location change _if needed._ That is, to
  auto-exit Ignore mode after navigating away from a blacklisted page, or
  auto-enter Ignore mode on blacklisted pages.

Clear artificial hover on blur

Previously, if you focused an element using an `f` command and then pressed
`<tab>` to focus the next element, or if the element was automatically blurred,
the element would still look hovered until you pressed `<escape>`. This is
because many `f` commands lock the `:hover` pseudo-class on their target
element. This commit unlocks that pseudo-class if that element blurs, preventing
elements from getting "stuck". It is only done if the element itself is blurred,
not if anything else is. That's to make sure that dropdown menus opened using
`zf` don't close unexpectedly.

Fix blacklisting of some XUL pages

Fixes #716.

Merge pull request #714 from mozillazg/zh-CN

Update zh-CN locale

Update zh-CN locale

VimFx v0.13.0

Update addons-linter

Merge branch 'master' into develop

Fix broken link in tools.md

Drop support for Firefox < 45

Don't set the width of the button in CSS

It is not needed since bug 1208715 was fixed, which was released in Firefox 44.
See #708, #702 and #591.

Fix text input focus issues in non-multi-process

Sometimes when focusing text inputs, it wouldn't really be focused and VimFx
wouldn't recognize it as editable. This was because of commit 33d1fdeb, where I
somehow looked for the 'context' attribute instead of the 'contextmenu'
attribute.

Update copyright years

Fix Find mode being exited on location change

Fixes #710.

Disallow old version of VimFx to communicate with new version

Commit 865fdaba attempted to fix an issue where frame script message listeners
from the old version of VimFx wasn't shut down properly when VimFx was updated.

Since then, the problem has become very rare, but unfortunately still happens
occasionally. I really have no idea why it can still happen. It might even be
that there's nothing that can be done due to the way Firefox works.

This commit tries to make any leftover frame script message listeners useless,
by adding the `BUILD_TIME` in all message names.

Add a preprocessor to simplify builds

Don't modify the global, shared scope in frame scripts

Show notification when entering Marks mode

Consistently name the translation ID for the `yy` notification

Add notification for the `O` command when no search bar

Simplify and improve Find mode auto-enter and -exit

In rare circumstances I've found that if you enter Find mode (via the `/`
command) very quickly after just having opened a new foreground tab which loads
a bit slowly, you could sometimes end up with the findbar focused but still in
Normal mode. This should no longer happen.

Set correct focusType on startup

Tweak the issue template

Make the button greyed out in Find mode

Fix toolbar button icon size in high dpi

Fixes #708 and #702. See also #591.

Thanks to @Hexcles for coming up with the solution and @dwhinham for testing.

Recognize text inputs in `about:preferences` dialogs as editable

For example, the search field in Privacy > Show cookies.

Unify `f` in XUL with `zF`

`zF` filters out some elements, based on specific XUL knowledge. This brings
those filters to `f`, for use in for example `about:preferences`.

Always trigger only 'mousedown' events on XUL tab elements

Previously, this was only done for the main browser tabs. It appears that the
same treatment is needed for `<tab>`s in `about:preferences`.

Make `gi` work in `about:config`

gulp: Simplify updating all locales with new wording

Clarify the blacklist option

- Improve wording in the Add-ons Manager. Explicitly say that the list is space
  separated, since several users had problems with that.
- Add default example blacklist patterns. It's much easier to adapt an example
  than to write something from scratch (or copy-paste). The default patterns are
  for example.com and example.org which are reserved for documentation purposes,
  so it doesn't matter that those get blacklisted by default.

See #704.

Update es locale

Fix uncaught error when using VimFx to disable VimFx

Fix "cannot access dead object" uncaught error on shutdown

Merge branch 'master' into develop

Fix loading of `frame.js` on startup

Improve click simulation

- Don't leak 'command' events to web pages. They're only needed for XUL.
- Don't generate 'mousedown' and 'mouseup' when simlating clicks for browser UI
  elements. They seem to sometimes trigger some buttons' actions twice. It also
  caused background tabs to be selected before closed when clicking on their
  close button, which caused the selected tab to change. However, an exception
  had to be made for tabs. 'mousedown' seems to be the only relevant event
  there.

Add the `T` command to open tab after current

I finally found a way to do it reliably. See #300 and #386.

Fix crash when showing the help dialog

Regression since commit 8f9c8550.

Add `__dirname` to config file scope

Inspired by Node.js' `__dirname` variable. This lets you more easily import
files relative to the config file.

(There's no need to add Node.js' `__filename`, because the config files are
always named `config.js` and `frame.js`.)

Improve `Cu.import`s

- Fixed two cases where things were accidentally imported into the global scope.
- Consistenly prefer the explicit `{a, b} = Cu.import('...', {})` style, rather
  than the implicit import-all-into-global-scope `Cu.import('...')` style.

Turn `anyPopupsOpen` into a class method for readability

Let `gL` deal with unvisited tabs instead of unread ones

Firefox considers a tab to be "unread" if it finishes loading in the background.
This means that if the current tab is loading, but very slowly, and you
therefore switch to another tab while waiting for it to finish, you can't use
`gl` to go back to the slowly-loading tab when it's done, because then it would
be marked as "unread", forcing you to use `gL` instead. This often tripped me
up.

This commit uses the notion of "unvisited" instead of "unread". This works much
better.

Fix `gi` after searching issues on github

After searching for issues on github, the search input gets removed from the DOM
and replaced with a new one. This means that the last focused text input is no
longer on the page, but `gi` still tried to focus it. This commit checks that
the last focused element really is present in the DOM first.

Fix focusType after searching issues on github

When searching for issues on github, the results are fetched with AJAX and then
inserted into the page. More accurately, the fetched content _replaces_ already
existing content on the page, including the search input. It turns out that
neither 'focus' nor 'blur' events are fired when a focused text input is removed
from the DOM (even though that actually blurs it and focuses `<body>`). This
caused VimFx to believe that the text input was still focused, which meant that
you had to press `<escape>` before you could use any VimFx commands. Using a
`MutationObserver`, this commit temporarily observes the currently focused
element (unless `focusType == 'none'`, because that's unnecessary and might
degrade performance). If the element gets removed, the current `focusType` is
updated, fixing the problem.

To check if an element gets removed from the DOM requires observing the _entire_
document tree, recursively. The `utils.onRemoved` function did (wrongly) not do
that, so it had to be updated.

Because of the update to `utils.onRemoved`, this commit also removes the
`MutationObserver`s for scrollable elements. The reason they were added in the
first place was to try to reduce memory consumption by pruning the list of
scrollable elements from elements removed from the DOM. However, the observers
were buggy: They were only triggered if _only_ the scrollable element was
removed, not if one of its parents were removed. Since this "buggy" behavior has
been used for quite some time now and it hasn't caused any memory problems, one
can draw the conclusion that the observers are not needed. That's good, because
it means that there's no need to add observers for the entire document on
basically _every_ page.

Recognize text inputs in the sidebar as editable

For example, the search field in the history sidebar.

Merge pull request #701 from pluser/localize_ja

Update Japanese translation

Update Japanese translation

Harden the `f` commands

It sucks that you can't trust the DOM. It sucks that on rare occasions, pressing
`f` shows no hints, but still enters Hints mode, leaving a
“element.href.startsWith is not a function” (or similar) error in the browser
console.

This commit tries to harden against such cases, by never trusting DOM properties
or methods to exist and be of the correct type. CoffeeScripts `?` is awesome for
this.

Streamline `vimfx.on` events

_Always_ pass an object with event-specific properties, instead of sometimes
passing data directly. This is more consistent, and more future-proof since it
allows passing additional data without breaking backwards compatibility.

Simplify the `config_file_directory` pref

- Set it to a normal system path, and let Firefox add `file://` and handle
  Windows paths.
- Expand path starting with `~/` or `~\` to the user's home directory.

Closes #700.

Fix mutation errors in some `f` commands

For example, `2f` is supposed to open the first link in a new background tab and
the second link in the current tab. However, both were opened in background tabs
due to accidental mutation.

Improve `npm run addons-linter`

Revert "Work around a CoffeeLint bug"

This reverts commit 0f280108c6a7bd84027c663abb34c4a03fefb091.

This is no longer needed since the bug has been fixed in CoffeeLint.

Update devDependencies

Update vim-like-key-notation to 1.0.0

Fix typo in comment in events.coffee

Only allow `<late>` in single-key shortcuts

Previously, it was allowed in any shortcut sequence, but it only made a
difference for the last character. It really only makes sense to use `<late>`
with singe-key shortcuts.

Avoid sending a synchronous message on every keydown

Use `prefs.get` directly in events-frame.coffee

... instead of using `messageManager.get`. This avoids synchronous messages,
which is a good thing. It violates the nice principle of only using the parsed
options of the `vimfx` object, but it doesn't really matter right now since only
four prefs are used in events-frame.coffee and they need little to none parsing.
One could probably pass the entire `vimfx.options` object down to frame scripts
when they start up and send updates whenever it updates, but let's do that when
a need for it comes up.

Use `vim.options` instead of `prefs.get` in commands.coffee

Use `@options` instead of `@_parent.options` in vim.coffee

Update tests to the new `vimfx.consumeKeyEvent` signature

Handle non-late keys on the UI layer

This is simpler and should be more robust. This is possible since we no longer
check get the focusType on each keydown.

Simplify handling of `uiEvent` in events.coffee

Fix activatable and adjustable keys handling

Regression since commit da8b3ccb.

Save the focusType instead of getting it on every keydown

This is simpler and more efficient. Also, we were basically already storing the
current focusType, since the button uses it to grey out when a text is focused.

Config API changes:

- `match` objects no longer have a `focus` property. It has been replaced with
  the `likelyConflict` property. (Theoretically a breaking change.)
- `vim.focusType` is now available and contains the current focus type.
- The `focusTypeChange` event now passes only the current `vim` object to
  listeners, instead of an object of data. Use `vim.focusType` to get the new
  focusType. (Theoretically a breaking change.)

Fix count for the `I` command

Silly mistake from commit 1176cde8.

Fix yet some uncaught errors on shutdown

Fix "args.messageManager.sendAsyncMessage is no a function" errors

A continuation of commit 14d46629.

Allow to temporarily enter Ignore mode based on focusType

Currently supports the wasavi extension and CodeMirror's Vim mode.

Fixes #532.

Improve commit e0ae646e

> Fix "invokeListener is not a function" uncaught errors

The commit indeed solved the above problem, but apparently replaced it with
another. When `invokeListener` has been `null`ed out, a copy of it can try to
reference things that also have been `null`ed out. So instead of storing copies
of it, we now check if the function exists before calling it. Otherwise, simply
do nothing. This commit also applies this to _all_ places `invokeListener` is
used.

Improve Ignore mode and the blacklist

When you reloaded the page or visited some other page in the same time while in
Ignore mode, you'd always end up in Normal mode (unless the newly loaded page
was blacklisted). Now, you stay in Ignore mode in that case. This lets you press
`i` and browse around in that tab in Ignore mode, without having to press `i`
again any time a full page reload is caused.

However, if Ignore mode was entered automatically because of the blacklist, it
is also exited as expected if you browse to a non-blacklisted page.

This new behavior is possible by tracking the "type" of the Ignore mode. There
are currently two types, 'explicit' and 'blacklist', which correspond to the
above two cases.

Improve blacklist documentation

Fix issues when updating VimFx

After having updated VimFx, trying to use the `f` command on toggle buttons
often failed. This was because the frame script message listeners from the old
version wasn't shut down properly, which resulted in there being _two_ listeners
for the message to simulate a click on an element. The effects of this was
especially noticeable on toggle buttons, because clicking a toggle button twice
is a no-op. That gave the impression of VimFx failing to simulate a click at
all.

I think this erraneous shutdown behavior must have been introduced in commit
24b701e9, which switched from a synchronous message passing to an asynchronous
one in bootstrap.coffee. Previously, the shutdown message listener for frame
scripts had to be added after a timeout. Since mentioned commit, that timeout is
added in the response callback for the mentioned asynchronous message, which
should make the timeout unnecessary, but the timeout was still kept in that
commit. It shouldn't matter, but somehow it does. Removing the timeout fixes the
double message listeners problem, and does not seem to re-introduce the problems
that were fixed be adding the timeout in the first place (commit ec3a4394).

Fix "invokeListener is not a function" uncaught errors

Fix `@popupPassThrough` for menus in frames

When a menu, such as a context menu is open, VimFx is automatically disabled to
allow using the access keys of the open menu, as well as pressing `<escape>` to
close the menu. However, this used not to work for the context menus in the
devtools and in about:config. Now it does.

This also fixes a bug where VimFx stopped being automatically disabled after
closing a sub-menu of a context menu.

Treat everything in the devtools as adjustable

Many things in the devtools can be "adjusted" with the arrow keys. For example,
if you `console.log` an object you can click it to get an interactive inspection
tree of that object. The tree can be navigated using the arrow keys, but not if
you, for example, use the arrow keys for VimFx's scrolling commands. With this
commit, that is no longer a problem.

Add better hints support for CodeMirror

Consider multimedia elements as adjustable

`<video>`, `<audio>`, `<embed>` and `<object>`. This allows pressing `<space>`
to toggle between play and pause, for instance.

This also allows to get rid of the check for fullscreen elements. That's good,
because _any_ element can be fullscreened, not just `<video>` elements.

Replace element `instanceof` checks with `.localName`

KISS.

Note: `instanceof` checks are still often useful for XUL elements, because some
interfaces are extended by several elements.

Also note that `.localName` is used instead of `.nodeName` because many XUL
pages embed HTML elements. When mixing namespaces like that, the `.nodeName`s of
HTML elements will start with `html:`, while `.localName` skips the prefix.
`.localName` also nicely always returns valid HTML node names in lowercase.

Split `gl` into `gl` and `gL`

`gl` selects the most recent tab. Simple, right? But what if you open a
background tab? Which is the most recent tab now? Or if you open several
background tabs?

Previously, if you opened several background tabs and then pressed `gl`, the
last opened new background tab would be selected. That behavior just happened to
be.

In my opinion, it is more consistent if `gl` always selects the last _visited_
tab. An unread background tab has _not_ been visited (yet). This commit makes
this change.

If there is only one visited tab (but possibly several unread tabs), a
notification is shown telling that there is no most recent tab.

The `gL` command selects the oldest unread tab. This is useful when having
opened a bunch of background tabs. `gL` then lets you step them through in the
order you opened them. (If there are no unread tabs, a notification is shown.)

In other words, `gl` deals with _visited_ tabs only (from now on), while `gL`
deals with _unread_ tabs only.

The motivation for this commit came from piroor/treestyletab#874.

Clean up the es locale